pythonlings 0.3.0__py3-none-any.whl

pythonlings/curriculum/exercises/testing/testing2.py

@@ -0,0 +1,15 @@
+# Exercise: Testing 2
+# I AM NOT DONE
+#
+# An assert can carry an optional message that is shown when it fails:
+#   assert condition, "helpful message"
+#
+# Replace ??? with the correct expected value AND complete the message
+# so the assertion has the form:
+#   assert square(5) == ???, "5 squared should be 25"
+
+def square(x):
+    return x * x
+
+
+assert square(5) == ???, "???"

pythonlings/curriculum/exercises/testing/testing3.py

@@ -0,0 +1,19 @@
+# Exercise: Testing 3
+# I AM NOT DONE
+#
+# Tests are usually wrapped in a function whose name starts with `test_`.
+# When the function is called it either runs to completion (pass) or raises
+# an AssertionError (fail).
+#
+# Complete `test_add` so it asserts:
+#   add(2, 3) == 5
+#   add(0, 0) == 0
+# A correct test runs without raising.
+
+def add(a, b):
+    return a + b
+
+
+def test_add():
+    # write assertions here
+    pass

pythonlings/curriculum/exercises/testing/testing4.py

@@ -0,0 +1,19 @@
+# Exercise: Testing 4
+# I AM NOT DONE
+#
+# A test function can (and usually should) contain *multiple* assertions —
+# one for each behaviour you want to verify.
+#
+# Complete `test_is_even` so it asserts ALL of the following:
+#   is_even(0)  is True
+#   is_even(2)  is True
+#   is_even(7)  is False
+#   is_even(-4) is True
+
+def is_even(n):
+    return n % 2 == 0
+
+
+def test_is_even():
+    # write four assertions here
+    pass

pythonlings/curriculum/exercises/testing/testing5.py

@@ -0,0 +1,18 @@
+# Exercise: Testing 5
+# I AM NOT DONE
+#
+# Good tests exercise a function with several different inputs.
+# Complete `test_clamp` to verify `clamp(value, lo, hi)` for each case:
+#   clamp(5,  0, 10) == 5    (inside range)
+#   clamp(-3, 0, 10) == 0    (below lo, should return lo)
+#   clamp(15, 0, 10) == 10   (above hi, should return hi)
+#   clamp(0,  0, 10) == 0    (at boundary lo)
+#   clamp(10, 0, 10) == 10   (at boundary hi)
+
+def clamp(value, lo, hi):
+    return max(lo, min(value, hi))
+
+
+def test_clamp():
+    # write five assertions here
+    pass

pythonlings/curriculum/exercises/testing/testing6.py

@@ -0,0 +1,27 @@
+# Exercise: Testing 6
+# I AM NOT DONE
+#
+# Sometimes the correct behaviour is for a function to *raise* an exception.
+# Test that with a try/except block:
+#
+#   try:
+#       call_that_should_raise()
+#       assert False, "expected an exception but none was raised"
+#   except SomeError:
+#       pass  # good — exception was raised as expected
+#
+# Complete `test_parse_positive` so it:
+#   1. Asserts parse_positive("42") == 42  (happy path)
+#   2. Verifies that parse_positive("-1") raises ValueError
+
+def parse_positive(s):
+    n = int(s)
+    if n < 0:
+        raise ValueError(f"{n} is not positive")
+    return n
+
+
+def test_parse_positive():
+    # 1. assert the happy path
+    # 2. use try/except to verify ValueError is raised for "-1"
+    pass

pythonlings/curriculum/exercises/testing/testing7.py

@@ -0,0 +1,27 @@
+# Exercise: Testing 7
+# I AM NOT DONE
+#
+# Beyond checking that an exception is raised, you often need to verify
+# its *message*. Capture the exception with `as e` and inspect `str(e)`:
+#
+#   try:
+#       risky()
+#       assert False, "expected ValueError"
+#   except ValueError as e:
+#       assert "some text" in str(e), f"unexpected message: {e}"
+#
+# Complete `test_divide_message` so it:
+#   1. Asserts divide(10, 2) == 5.0
+#   2. Catches the ValueError raised by divide(5, 0) and asserts
+#      the message contains "zero"
+
+def divide(a, b):
+    if b == 0:
+        raise ValueError("cannot divide by zero")
+    return a / b
+
+
+def test_divide_message():
+    # 1. happy-path assertion
+    # 2. catch ValueError and check its message contains "zero"
+    pass

pythonlings/curriculum/exercises/testing/testing8.py

@@ -0,0 +1,29 @@
+# Exercise: Testing 8
+# I AM NOT DONE
+#
+# pytest's @pytest.mark.parametrize runs the same test for many inputs.
+# Without pytest's collector you can get the same benefit by looping:
+#
+#   def test_something():
+#       cases = [(input1, expected1), (input2, expected2), ...]
+#       for inp, expected in cases:
+#           assert fn(inp) == expected, f"fn({inp!r}) expected {expected!r}"
+#
+# Complete `test_fahrenheit_to_celsius` by filling in the `cases` list with
+# at least these four (fahrenheit, celsius) pairs:
+#   (32,  0.0)
+#   (212, 100.0)
+#   (98.6, 37.0)
+#   (-40, -40.0)
+# The loop body is already written — only `cases` needs to be filled in.
+
+def fahrenheit_to_celsius(f):
+    return round((f - 32) * 5 / 9, 10)
+
+
+def test_fahrenheit_to_celsius():
+    cases = []  # replace with a list of (fahrenheit, celsius) tuples
+    for f, expected in cases:
+        assert abs(fahrenheit_to_celsius(f) - expected) < 1e-6, (
+            f"fahrenheit_to_celsius({f}) expected {expected}"
+        )

pythonlings/curriculum/exercises/testing/testing9.py

@@ -0,0 +1,30 @@
+# Exercise: Testing 9
+# I AM NOT DONE
+#
+# A *fixture* is a helper that builds the test data your tests need.
+# In plain Python you write a setup function and call it at the top of
+# each test that needs it:
+#
+#   def make_shopping_cart():
+#       return {"items": [], "discount": 0}
+#
+#   def test_add_item():
+#       cart = make_shopping_cart()
+#       ...
+#
+# `make_user` below is the fixture. Complete `test_user_greeting` so it:
+#   1. Calls `make_user()` to get a fresh user dict.
+#   2. Asserts that `greet(user)` returns "Hello, Alice!"
+
+def make_user():
+    return {"name": "Alice", "age": 30}
+
+
+def greet(user):
+    return f"Hello, {user['name']}!"
+
+
+def test_user_greeting():
+    # 1. call make_user() to get the fixture
+    # 2. assert greet(user) == "Hello, Alice!"
+    pass

pythonlings/curriculum/exercises/tuples/tuples1.py

@@ -0,0 +1,7 @@
+# Exercise: Tuples 1
+# I AM NOT DONE
+#
+# Create a tuple called `point` containing the two integers 3 and 4,
+# in that order.
+
+point = ???

pythonlings/curriculum/exercises/tuples/tuples10.py

@@ -0,0 +1,26 @@
+# Exercise: Tuples 10
+# I AM NOT DONE
+#
+# You are given a list of (name, score) tuples representing student results.
+#
+# Complete the code so that:
+#   `top_student` — the name of the student with the highest score
+#   `average`     — the average score (total / number of students), as a float
+#   `passed`      — a list of names whose score is >= 60, in the original order
+#
+# Expected:
+#   top_student == "Diana"
+#   average     == 71.0
+#   passed      == ["Alice", "Diana", "Eve"]
+
+results = [
+    ("Alice", 85),
+    ("Bob", 42),
+    ("Carol", 55),
+    ("Diana", 91),
+    ("Eve", 82),
+]
+
+top_student = ???
+average = ???
+passed = ???

pythonlings/curriculum/exercises/tuples/tuples2.py

@@ -0,0 +1,11 @@
+# Exercise: Tuples 2
+# I AM NOT DONE
+#
+# You have a tuple called `rgb` with three values: red, green, blue.
+# Retrieve the first element and store it in `red`,
+# and the last element and store it in `blue`.
+
+rgb = (255, 128, 0)
+
+red = ???
+blue = ???

pythonlings/curriculum/exercises/tuples/tuples3.py

@@ -0,0 +1,9 @@
+# Exercise: Tuples 3
+# I AM NOT DONE
+#
+# Unpack the tuple `coordinates` into three separate variables:
+# `x`, `y`, and `z`, using a single unpacking assignment.
+
+coordinates = (10, 20, 30)
+
+???, ???, ??? = coordinates

pythonlings/curriculum/exercises/tuples/tuples4.py

@@ -0,0 +1,8 @@
+# Exercise: Tuples 4
+# I AM NOT DONE
+#
+# A single-element tuple requires a trailing comma.
+# Create a tuple called `solo` that contains only the integer 42.
+# Hint: (42) is just parentheses — you need a comma.
+
+solo = (42)

pythonlings/curriculum/exercises/tuples/tuples5.py

@@ -0,0 +1,12 @@
+# Exercise: Tuples 5
+# I AM NOT DONE
+#
+# Tuples are immutable — you cannot change an element in place.
+# Instead, build a NEW tuple called `updated` that is the same as
+# `original` but with the second element (index 1) replaced by 99.
+#
+# Expected: updated == (10, 99, 30)
+
+original = (10, 20, 30)
+
+updated = original  # fix this — do not modify original, build a new tuple

pythonlings/curriculum/exercises/tuples/tuples6.py

@@ -0,0 +1,15 @@
+# Exercise: Tuples 6
+# I AM NOT DONE
+#
+# Complete the function `min_max` so that it returns a tuple of two
+# values: (minimum, maximum) of the given list.
+#
+# Do not use multiple return statements — return both values as a
+# single tuple in one `return` statement.
+
+
+def min_max(numbers):
+    pass  # replace with a return statement that returns (min, max)
+
+
+result = min_max([4, 1, 7, 2, 9, 3])

pythonlings/curriculum/exercises/tuples/tuples7.py

@@ -0,0 +1,14 @@
+# Exercise: Tuples 7
+# I AM NOT DONE
+#
+# Swap the values of `a` and `b` using Python's tuple swap idiom —
+# a single assignment statement with no temporary variable.
+#
+# After the swap: a should be 99, b should be 7.
+
+a = 7
+b = 99
+
+# swap a and b in one line using tuple unpacking
+a = b
+b = a

pythonlings/curriculum/exercises/tuples/tuples8.py

@@ -0,0 +1,13 @@
+# Exercise: Tuples 8
+# I AM NOT DONE
+#
+# Iterate over the tuple `scores` and collect every score that is
+# greater than or equal to 60 into a list called `passing`.
+#
+# Expected: passing == [85, 92, 60, 74]
+
+scores = (45, 85, 92, 55, 60, 74)
+
+passing = []
+for score in scores:
+    pass  # append score to passing if it is >= 60

pythonlings/curriculum/exercises/tuples/tuples9.py

@@ -0,0 +1,18 @@
+# Exercise: Tuples 9
+# I AM NOT DONE
+#
+# Tuples can be used as dictionary keys because they are hashable.
+# Complete the dictionary `grid` so that:
+#   - the key (0, 0) maps to "origin"
+#   - the key (1, 0) maps to "right"
+#   - the key (0, 1) maps to "up"
+#
+# Then look up `grid[(1, 0)]` and store the result in `label`.
+
+grid = {
+    ???: "origin",
+    ???: "right",
+    ???: "up",
+}
+
+label = ???

pythonlings/curriculum/exercises/type_hints/type_hints1.py

@@ -0,0 +1,9 @@
+# Exercise: Type Hints 1
+# I AM NOT DONE
+#
+# Annotate the module-level variable `count` so that Python knows it is an `int`.
+# The declaration should read:  count: int = 0
+#
+# Right now `count` has no annotation.  Add the `: int` annotation.
+
+count = 0

pythonlings/curriculum/exercises/type_hints/type_hints2.py

@@ -0,0 +1,13 @@
+# Exercise: Type Hints 2
+# I AM NOT DONE
+#
+# Annotate the function `greet` so that:
+#   - parameter `name` is annotated as `str`
+#   - parameter `times` is annotated as `int`
+#   - the return type is annotated as `str`
+#
+# The signature should read:
+#   def greet(name: str, times: int) -> str:
+
+def greet(name, times):
+    return (name + " ") * times

pythonlings/curriculum/exercises/type_hints/type_hints3.py

@@ -0,0 +1,13 @@
+# Exercise: Type Hints 3
+# I AM NOT DONE
+#
+# Annotate the function `total` to use parameterized generic types:
+#   - parameter `scores` should be annotated as `list[int]`
+#   - parameter `labels` should be annotated as `dict[str, int]`
+#   - the return type should be annotated as `int`
+#
+# The signature should read:
+#   def total(scores: list[int], labels: dict[str, int]) -> int:
+
+def total(scores, labels):
+    return sum(scores) + sum(labels.values())

pythonlings/curriculum/exercises/type_hints/type_hints4.py

@@ -0,0 +1,21 @@
+# Exercise: Type Hints 4
+# I AM NOT DONE
+#
+# Annotate the function `find_index` to express that a value might be absent:
+#   - parameter `items` should be annotated as `list[str]`
+#   - parameter `target` should be annotated as `str`
+#   - the return type should be `int | None`  (the value or None when not found)
+#
+# The signature should read:
+#   def find_index(items: list[str], target: str) -> int | None:
+#
+# Keep the `from __future__ import annotations` line below: it lets the modern
+# `int | None` syntax work on Python 3.9 and 3.10 as well.
+from __future__ import annotations
+
+
+def find_index(items, target):
+    try:
+        return items.index(target)
+    except ValueError:
+        return None

pythonlings/curriculum/exercises/type_hints/type_hints5.py

@@ -0,0 +1,15 @@
+# Exercise: Type Hints 5
+# I AM NOT DONE
+#
+# Annotate the function `bounding_box` with a fixed-length tuple return type:
+#   - parameter `points` should be annotated as `list[tuple[float, float]]`
+#   - the return type should be `tuple[float, float, float, float]`
+#     (representing min_x, min_y, max_x, max_y)
+#
+# The signature should read:
+#   def bounding_box(points: list[tuple[float, float]]) -> tuple[float, float, float, float]:
+
+def bounding_box(points):
+    xs = [p[0] for p in points]
+    ys = [p[1] for p in points]
+    return (min(xs), min(ys), max(xs), max(ys))

pythonlings/curriculum/exercises/type_hints/type_hints6.py

@@ -0,0 +1,16 @@
+# Exercise: Type Hints 6
+# I AM NOT DONE
+#
+# Create a type alias `Vector` that equals `list[float]`, then annotate
+# the function `scale`:
+#   - parameter `v` should be annotated as `Vector`
+#   - parameter `factor` should be annotated as `float`
+#   - the return type should be `Vector`
+#
+# Write:
+#   Vector = list[float]
+#
+#   def scale(v: Vector, factor: float) -> Vector:
+
+def scale(v, factor):
+    return [x * factor for x in v]

pythonlings/curriculum/exercises/type_hints/type_hints7.py

@@ -0,0 +1,19 @@
+# Exercise: Type Hints 7
+# I AM NOT DONE
+#
+# Annotate the function `apply_twice` using `Callable` from `typing`:
+#   - parameter `func` should be annotated as `Callable[[int], int]`
+#     (a function that takes one int and returns an int)
+#   - parameter `value` should be annotated as `int`
+#   - the return type should be `int`
+#
+# Remember to import `Callable` from `typing`.
+#
+# The signature should read:
+#   def apply_twice(func: Callable[[int], int], value: int) -> int:
+
+from typing import Callable
+
+
+def apply_twice(func, value):
+    return func(func(value))

pythonlings/curriculum/exercises/type_hints/type_hints8.py

@@ -0,0 +1,27 @@
+# Exercise: Type Hints 8
+# I AM NOT DONE
+#
+# Fully annotate the function `summarise`:
+#   - parameter `records` should be annotated as `list[dict[str, int]]`
+#   - parameter `key` should be annotated as `str`
+#   - parameter `default` should be annotated as `int | None`
+#   - the return type should be `dict[str, int | None]`
+#
+# The signature should read:
+#   def summarise(
+#       records: list[dict[str, int]],
+#       key: str,
+#       default: int | None,
+#   ) -> dict[str, int | None]:
+#
+# Keep the `from __future__ import annotations` line below: it lets the modern
+# `int | None` syntax work on Python 3.9 and 3.10 as well.
+from __future__ import annotations
+
+
+def summarise(records, key, default):
+    return {
+        "count": len(records),
+        "total": sum(r.get(key, default or 0) for r in records),
+        "missing": default,
+    }

pythonlings/curriculum/exercises/variables/variables1.py

@@ -0,0 +1,10 @@
+# Exercise: Variables 1
+# ----------------------
+# I AM NOT DONE
+#
+# Replace each ??? with a value of the right type:
+#   a -> int 0,  b -> float 0.0,  c -> empty string
+
+a = ???
+b = ???
+c = ???

pythonlings/curriculum/exercises/variables/variables10.py

@@ -0,0 +1,14 @@
+# Exercise: Variables 10
+# I AM NOT DONE
+#
+# Combine everything: given width and height of a rectangle, compute:
+#   area      = width * height
+#   perimeter = 2 * (width + height)
+#   diagonal  = (width**2 + height**2) ** 0.5   (Pythagorean theorem)
+# width = 3, height = 4.  Replace each ??? with the correct expression.
+
+width = 3
+height = 4
+area = ???
+perimeter = ???
+diagonal = ???

pythonlings/curriculum/exercises/variables/variables2.py

@@ -0,0 +1,11 @@
+# Exercise: Variables 2
+# ----------------------
+# I AM NOT DONE
+#
+# Set a, b, c so that:
+#   a + b == 13,  a - b == 7,  a * b == 30,  a % b == 1
+#   str(a) + c == "10hello",  c * b == "hellohellohello"
+
+a = ???
+b = ???
+c = ???

pythonlings/curriculum/exercises/variables/variables3.py

@@ -0,0 +1,11 @@
+# Exercise: Variables 3
+# I AM NOT DONE
+#
+# Assign three variables of different types:
+#   count    -> the integer 7
+#   ratio    -> the float 0.5
+#   is_ready -> the boolean True
+
+count = ???
+ratio = ???
+is_ready = ???

pythonlings/curriculum/exercises/variables/variables4.py

@@ -0,0 +1,9 @@
+# Exercise: Variables 4
+# I AM NOT DONE
+#
+# Reassign the variable `score` three times so that after all three
+# statements its final value is 42.
+# Start from score = 0, then reassign it twice more to reach 42.
+
+score = 0
+# Reassign score here (two more statements needed)

pythonlings/curriculum/exercises/variables/variables5.py

@@ -0,0 +1,11 @@
+# Exercise: Variables 5
+# I AM NOT DONE
+#
+# Use augmented assignment operators to update `total`:
+#   Start with total = 10, then add 5, then subtract 3, then multiply by 4.
+# Fill in the ??? placeholders with the correct augmented-assignment operators.
+
+total = 10
+total ???= 5
+total ???= 3
+total ???= 4

pythonlings/curriculum/exercises/variables/variables6.py

@@ -0,0 +1,9 @@
+# Exercise: Variables 6
+# I AM NOT DONE
+#
+# Use multiple assignment (tuple unpacking) to assign both variables in one line:
+#   x -> 1,  y -> 2
+# Replace the two separate assignments below with a single unpacking statement.
+
+x = ???
+y = ???

pythonlings/curriculum/exercises/variables/variables7.py

@@ -0,0 +1,10 @@
+# Exercise: Variables 7
+# I AM NOT DONE
+#
+# Swap the values of `a` and `b` using a single Pythonic swap statement,
+# so that after the swap a == 20 and b == 10.
+# Replace the ??? line with the swap.
+
+a = 10
+b = 20
+???

pythonlings/curriculum/exercises/variables/variables8.py

@@ -0,0 +1,12 @@
+# Exercise: Variables 8
+# I AM NOT DONE
+#
+# Use type() to inspect a value and type-conversion functions to create new values:
+#   - `kind` should be the type of 3.14 (i.e. type(3.14))
+#   - `as_int` should be 3.14 converted to an int using int()
+#   - `as_str` should be 42 converted to a string using str()
+# Replace each ??? with the correct expression.
+
+kind = ???
+as_int = ???
+as_str = ???

pythonlings/curriculum/exercises/variables/variables9.py

@@ -0,0 +1,10 @@
+# Exercise: Variables 9
+# I AM NOT DONE
+#
+# Define an ALL_CAPS constant TAX_RATE equal to 0.2 (20 %), then compute
+# `total_price` as the price after tax: price * (1 + TAX_RATE).
+# Replace the ??? placeholders with the correct values/expressions.
+
+TAX_RATE = ???
+price = 50
+total_price = ???