pythonlings 0.3.0__py3-none-any.whl

pythonlings/curriculum/exercises/functional/functional8.py

@@ -0,0 +1,13 @@
+# Exercise: Functional 8
+# I AM NOT DONE
+#
+# Use `functools.reduce` to compute the PRODUCT of all numbers in `numbers`.
+# `reduce(func, iterable)` applies `func` cumulatively:
+#   reduce(f, [a, b, c]) → f(f(a, b), c)
+# Replace ??? with a lambda that multiplies two numbers together.
+
+from functools import reduce
+
+numbers = [1, 2, 3, 4, 5]
+
+product = reduce(???, numbers)

pythonlings/curriculum/exercises/functional/functional9.py

@@ -0,0 +1,15 @@
+# Exercise: Functional 9
+# I AM NOT DONE
+#
+# Use the built-in `any()` and `all()` to fill in two expressions below.
+#
+# `has_negative` should be True if ANY number in `numbers` is negative.
+# `all_positive` should be True if ALL numbers in `positives` are positive (> 0).
+#
+# Replace each ??? with the correct generator expression inside any()/all().
+
+numbers = [3, -1, 4, 1, 5]
+positives = [2, 7, 11, 5]
+
+has_negative = any(???)
+all_positive = all(???)

pythonlings/curriculum/exercises/functions/functions1.py

@@ -0,0 +1,8 @@
+# Exercise: Functions 1
+# ----------------------
+# I AM NOT DONE
+#
+# Fix the function below so it takes two numbers and returns their average.
+
+def average():
+    return (a + b) / 2

pythonlings/curriculum/exercises/functions/functions10.py

@@ -0,0 +1,19 @@
+# Exercise: Functions 10
+# I AM NOT DONE
+#
+# Complete the helper function `is_palindrome` that takes a string and
+# returns True if it reads the same forwards and backwards (ignoring
+# case), and False otherwise.
+# Example: is_palindrome("Racecar") -> True
+# Example: is_palindrome("hello") -> False
+#
+# Then use it to build `palindromes`: a list of all strings from `words`
+# that are palindromes.
+
+words = ["racecar", "hello", "level", "world", "madam", "python", "noon"]
+
+def is_palindrome(s):
+    # Hint: compare s.lower() with its reverse (s.lower()[::-1])
+    pass
+
+palindromes = [w for w in words if is_palindrome(w)]

pythonlings/curriculum/exercises/functions/functions2.py

@@ -0,0 +1,9 @@
+# Exercise: Functions 2
+# I AM NOT DONE
+#
+# Define a function `greet` that takes no arguments and returns the
+# string "hello". Then call it and store the result in `message`.
+
+# define greet here
+
+message = ???

pythonlings/curriculum/exercises/functions/functions3.py

@@ -0,0 +1,8 @@
+# Exercise: Functions 3
+# I AM NOT DONE
+#
+# Define a function `double` that takes one number as a parameter and
+# returns that number multiplied by 2.
+
+def double():
+    return n * 2

pythonlings/curriculum/exercises/functions/functions4.py

@@ -0,0 +1,8 @@
+# Exercise: Functions 4
+# I AM NOT DONE
+#
+# Define a function `square` that takes one number and returns its square
+# (the number multiplied by itself). Make sure to use the `return` keyword.
+
+def square(n):
+    n * n

pythonlings/curriculum/exercises/functions/functions5.py

@@ -0,0 +1,11 @@
+# Exercise: Functions 5
+# I AM NOT DONE
+#
+# Define a function `make_greeting` that takes a `name` parameter and an
+# optional `greeting` parameter with a default value of "Hello".
+# It should return the string "<greeting>, <name>!".
+# Example: make_greeting("Alice") -> "Hello, Alice!"
+# Example: make_greeting("Bob", "Hi") -> "Hi, Bob!"
+
+def make_greeting(name, greeting):
+    return f"{greeting}, {name}!"

pythonlings/curriculum/exercises/functions/functions6.py

@@ -0,0 +1,16 @@
+# Exercise: Functions 6
+# I AM NOT DONE
+#
+# The function `describe_pet` takes two parameters: `name` and `animal_type`.
+# It returns "My <animal_type> is named <name>.".
+#
+# The call below mixes up the argument order.
+# Fix it by using keyword arguments so the result is correct regardless
+# of position.
+# Store the fixed call result in `description`.
+
+def describe_pet(name, animal_type):
+    return f"My {animal_type} is named {name}."
+
+# This call has the arguments in the wrong order:
+description = describe_pet("dog", "Buddy")

pythonlings/curriculum/exercises/functions/functions7.py

@@ -0,0 +1,11 @@
+# Exercise: Functions 7
+# I AM NOT DONE
+#
+# Define a function `total` that accepts any number of positional arguments
+# using `*args` and returns their sum.
+# Example: total(1, 2, 3) -> 6
+# Example: total(10) -> 10
+# Example: total() -> 0
+
+def total(*args):
+    pass

pythonlings/curriculum/exercises/functions/functions8.py

@@ -0,0 +1,10 @@
+# Exercise: Functions 8
+# I AM NOT DONE
+#
+# Define a function `build_profile` that accepts any number of keyword
+# arguments using `**kwargs` and returns them as a plain dict.
+# Example: build_profile(name="Alice", age=30) -> {"name": "Alice", "age": 30}
+# Example: build_profile() -> {}
+
+def build_profile(**kwargs):
+    pass

pythonlings/curriculum/exercises/functions/functions9.py

@@ -0,0 +1,16 @@
+# Exercise: Functions 9
+# I AM NOT DONE
+#
+# Define a function `min_max` that takes a list of numbers and returns a
+# tuple of (minimum, maximum).
+# Example: min_max([3, 1, 4, 1, 5, 9]) -> (1, 9)
+#
+# Then unpack the result into two variables `lo` and `hi`.
+
+numbers = [3, 1, 4, 1, 5, 9, 2, 6]
+
+def min_max(nums):
+    return min(nums), max(nums)
+
+lo = min_max(numbers)
+hi = min_max(numbers)

pythonlings/curriculum/exercises/generators/generators1.py

@@ -0,0 +1,13 @@
+# Exercise: Generators 1
+# I AM NOT DONE
+#
+# Complete `count_up_to(n)` so it is a generator function that yields
+# the integers 1, 2, ..., n one at a time.
+#
+# Hint: replace the `pass` with a `yield` statement inside the loop.
+
+
+def count_up_to(n):
+    for i in range(1, n + 1):
+        # yield the value here
+        pass

pythonlings/curriculum/exercises/generators/generators10.py

@@ -0,0 +1,16 @@
+# Exercise: Generators 10
+# I AM NOT DONE
+#
+# Complete `running_total(numbers)` — a streaming generator that takes any
+# iterable of numbers and yields the cumulative (running) sum after each item.
+#
+# Example: running_total([1, 2, 3, 4]) → 1, 3, 6, 10
+#
+# The broken version yields each raw number unchanged instead of accumulating.
+
+
+def running_total(numbers):
+    total = 0
+    for n in numbers:
+        # Bug: yields n instead of the accumulated total.
+        yield n

pythonlings/curriculum/exercises/generators/generators2.py

@@ -0,0 +1,17 @@
+# Exercise: Generators 2
+# I AM NOT DONE
+#
+# `squares(n)` is already a correct generator that yields 1², 2², ..., n².
+# Your task: call `squares(5)` and convert the result to a list, storing it
+# in the variable `result`.
+#
+# Hint: a generator object is not a list — wrap it with list().
+
+
+def squares(n):
+    for i in range(1, n + 1):
+        yield i * i
+
+
+# Replace None with the correct expression.
+result = None

pythonlings/curriculum/exercises/generators/generators3.py

@@ -0,0 +1,19 @@
+# Exercise: Generators 3
+# I AM NOT DONE
+#
+# `evens_up_to(n)` should be a generator that yields every even number
+# from 2 up to and including n (if n is even), e.g. evens_up_to(8) → 2 4 6 8.
+#
+# Use a for loop over range and yield only the even numbers.
+# The collected list is built by iterating the generator with a for loop.
+
+
+def evens_up_to(n):
+    for i in range(1, n + 1):
+        # yield only when i is even
+        pass
+
+
+collected = []
+for value in evens_up_to(8):
+    collected.append(value)

pythonlings/curriculum/exercises/generators/generators4.py

@@ -0,0 +1,12 @@
+# Exercise: Generators 4
+# I AM NOT DONE
+#
+# Use a generator expression (not a list comprehension) to build a lazy
+# sequence of cubes: 1³, 2³, 3³, ..., 5³.
+#
+# Store the generator expression in `cube_gen`.
+# A generator expression looks like: (expr for var in iterable)
+
+
+# Replace None with a generator expression.
+cube_gen = None

pythonlings/curriculum/exercises/generators/generators5.py

@@ -0,0 +1,24 @@
+# Exercise: Generators 5
+# I AM NOT DONE
+#
+# Use `next()` to pull individual values from a generator one at a time.
+#
+# `letters` is a generator that yields 'a', 'b', 'c'.
+# Pull the first value into `first`, the second into `second`, and
+# the third into `third` — each with a separate call to next().
+#
+# Do NOT convert the whole generator to a list.
+
+
+def letters():
+    yield "a"
+    yield "b"
+    yield "c"
+
+
+gen = letters()
+
+# Replace each None with a next() call on gen.
+first = None
+second = None
+third = None

pythonlings/curriculum/exercises/generators/generators6.py

@@ -0,0 +1,20 @@
+# Exercise: Generators 6
+# I AM NOT DONE
+#
+# `natural_numbers()` must be an infinite generator that yields 1, 2, 3, 4, ...
+# without ever stopping.
+#
+# `first_ten` should be the list [1, 2, 3, ..., 10] — take only the first 10
+# values from the infinite generator using itertools.islice.
+#
+# Hint: import itertools, then use itertools.islice(natural_numbers(), 10).
+
+import itertools
+
+
+def natural_numbers():
+    # Bug: this yields nothing — make it yield 1, 2, 3, ... forever.
+    return
+
+
+first_ten = list(itertools.islice(natural_numbers(), 10))

pythonlings/curriculum/exercises/generators/generators7.py

@@ -0,0 +1,14 @@
+# Exercise: Generators 7
+# I AM NOT DONE
+#
+# Complete `fibonacci()` so it yields the Fibonacci sequence indefinitely:
+# 0, 1, 1, 2, 3, 5, 8, 13, ...
+#
+# The function should use `yield` inside a loop, updating two variables
+# (a, b) each iteration.  The broken version only yields `a` once and stops.
+
+
+def fibonacci():
+    a, b = 0, 1
+    # Bug: yields only once instead of looping forever.
+    yield a

pythonlings/curriculum/exercises/generators/generators8.py

@@ -0,0 +1,17 @@
+# Exercise: Generators 8
+# I AM NOT DONE
+#
+# Make `Countdown` iterable by implementing `__iter__`.
+#
+# `Countdown(n)` should iterate from n down to 1 (inclusive).
+# The class already stores `self.start`.  Add an `__iter__` method that
+# returns a generator (use `yield` inside it) — do NOT add `__next__`.
+#
+# Example: list(Countdown(3)) == [3, 2, 1]
+
+
+class Countdown:
+    def __init__(self, start):
+        self.start = start
+
+    # Bug: __iter__ is missing — add it so the class is iterable.

pythonlings/curriculum/exercises/generators/generators9.py

@@ -0,0 +1,26 @@
+# Exercise: Generators 9
+# I AM NOT DONE
+#
+# Implement the full iterator protocol on `Counter`.
+#
+# `Counter(stop)` should iterate over 0, 1, 2, ..., stop-1 — just like
+# range(stop).  You must implement both:
+#   __iter__(self)  — returns self
+#   __next__(self)  — returns the next value, or raises StopIteration
+#
+# The broken version never raises StopIteration, so it loops forever.
+
+
+class Counter:
+    def __init__(self, stop):
+        self.stop = stop
+        self.current = 0
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        # Bug: increments forever — add a StopIteration guard.
+        value = self.current
+        self.current += 1
+        return value

pythonlings/curriculum/exercises/itertools/itertools1.py

@@ -0,0 +1,10 @@
+# Exercise: Itertools 1
+# I AM NOT DONE
+#
+# Goal: Use itertools.chain to combine letters and numbers into one list.
+
+from itertools import chain
+
+letters = ["a", "b"]
+numbers = [1, 2, 3]
+combined = list(???)

pythonlings/curriculum/exercises/itertools/itertools2.py

@@ -0,0 +1,8 @@
+# Exercise: Itertools 2
+# I AM NOT DONE
+#
+# Goal: Use count and islice to collect the first four numbers starting at 10.
+
+from itertools import count, islice
+
+first_four = list(???)

pythonlings/curriculum/exercises/itertools/itertools3.py

@@ -0,0 +1,10 @@
+# Exercise: Itertools 3
+# I AM NOT DONE
+#
+# Goal: Use product to build every coordinate pair from xs and ys.
+
+from itertools import product
+
+xs = [0, 1]
+ys = ["low", "high"]
+coordinates = list(???)

pythonlings/curriculum/exercises/itertools/itertools4.py

@@ -0,0 +1,12 @@
+# Exercise: Itertools 4
+# I AM NOT DONE
+#
+# Goal: Use groupby to group sorted rows by category.
+
+from itertools import groupby
+
+rows = [("fruit", "apple"), ("fruit", "pear"), ("veg", "carrot")]
+grouped = {
+    category: [name for _, name in group]
+    for category, group in groupby(rows, key=??? )
+}

pythonlings/curriculum/exercises/itertools/itertools5.py

@@ -0,0 +1,9 @@
+# Exercise: Itertools 5
+# I AM NOT DONE
+#
+# Goal: Use accumulate to compute running totals.
+
+from itertools import accumulate
+
+values = [3, 4, 5, 6]
+running_totals = list(???)

pythonlings/curriculum/exercises/itertools/itertools6.py

@@ -0,0 +1,9 @@
+# Exercise: Itertools 6
+# I AM NOT DONE
+#
+# Goal: Use cycle and islice to repeat colors until you have six values.
+
+from itertools import cycle, islice
+
+colors = ["red", "blue"]
+repeated = list(???)

pythonlings/curriculum/exercises/itertools/itertools7.py

@@ -0,0 +1,10 @@
+# Exercise: Itertools 7
+# I AM NOT DONE
+#
+# Goal: Use zip_longest so missing right-side values become "?".
+
+from itertools import zip_longest
+
+left = ["a", "b", "c"]
+right = [1]
+pairs = list(???)

pythonlings/curriculum/exercises/itertools/itertools8.py

@@ -0,0 +1,18 @@
+# Exercise: Itertools 8
+# I AM NOT DONE
+#
+# Goal: Flatten batches, then collect every pair of adjacent flattened values.
+
+try:
+    from itertools import pairwise
+except ImportError:  # Python < 3.10
+    from itertools import tee
+
+    def pairwise(iterable):
+        a, b = tee(iterable)
+        next(b, None)
+        return zip(a, b)
+
+batches = [[1, 2], [3], [4, 5]]
+flattened = [item for batch in batches for item in batch]
+adjacent_pairs = list(???)

pythonlings/curriculum/exercises/json/json1.py

@@ -0,0 +1,10 @@
+# Exercise: Json 1
+# I AM NOT DONE
+#
+# Goal: Parse the JSON string and read the name field.
+
+import json
+
+raw = '{"name": "Ada", "language": "Python"}'
+data = ???
+name = data["name"]

pythonlings/curriculum/exercises/json/json2.py

@@ -0,0 +1,9 @@
+# Exercise: Json 2
+# I AM NOT DONE
+#
+# Goal: Serialize the payload with stable key order.
+
+import json
+
+payload = {"b": 2, "a": 1}
+text = ???

pythonlings/curriculum/exercises/json/json3.py

@@ -0,0 +1,10 @@
+# Exercise: Json 3
+# I AM NOT DONE
+#
+# Goal: Read nested data from a decoded JSON document.
+
+import json
+
+raw = '{"user": {"name": "Grace", "address": {"city": "London"}}}'
+profile = json.loads(raw)
+city = ???

pythonlings/curriculum/exercises/json/json4.py

@@ -0,0 +1,13 @@
+# Exercise: Json 4
+# I AM NOT DONE
+#
+# Goal: Use json.dump and json.load with a StringIO buffer.
+
+import io
+import json
+
+payload = {"ok": True, "count": 3}
+buffer = io.StringIO()
+json.dump(???, buffer)
+buffer.seek(0)
+restored = json.load(buffer)

pythonlings/curriculum/exercises/json/json5.py

@@ -0,0 +1,9 @@
+# Exercise: Json 5
+# I AM NOT DONE
+#
+# Goal: Use dict.get to provide a default for a missing JSON field.
+
+import json
+
+data = json.loads('{"name": "Pythonlings"}')
+timezone = ???

pythonlings/curriculum/exercises/json/json6.py

@@ -0,0 +1,10 @@
+# Exercise: Json 6
+# I AM NOT DONE
+#
+# Goal: Parse a JSON array and collect the active user names.
+
+import json
+
+raw = '[{"name": "Ada", "active": true}, {"name": "Lin", "active": false}, {"name": "Guido", "active": true}]'
+users = json.loads(raw)
+active_names = ???

pythonlings/curriculum/exercises/json/json7.py

@@ -0,0 +1,10 @@
+# Exercise: Json 7
+# I AM NOT DONE
+#
+# Goal: Decode settings, update one value, and encode them again.
+
+import json
+
+settings = json.loads('{"theme": "light", "font_size": 12}')
+settings["theme"] = ???
+encoded = json.dumps(settings, sort_keys=True)

pythonlings/curriculum/exercises/json/json8.py

@@ -0,0 +1,12 @@
+# Exercise: Json 8
+# I AM NOT DONE
+#
+# Goal: Round-trip a nested object without losing values.
+
+import json
+
+original = {"project": "pythonlings", "tags": ["python", "practice"], "meta": {"level": 3}}
+encoded = json.dumps(original, sort_keys=True)
+decoded = ???
+tag_count = len(decoded["tags"])
+level = decoded["meta"]["level"]

pythonlings/curriculum/exercises/lists/lists1.py

@@ -0,0 +1,7 @@
+# Exercise: Lists 1
+# I AM NOT DONE
+#
+# Create a list called `colors` containing the three strings
+# "red", "green", and "blue", in that order.
+
+colors = ???

pythonlings/curriculum/exercises/lists/lists10.py

@@ -0,0 +1,28 @@
+# Exercise: Lists 10
+# I AM NOT DONE
+#
+# You are given a list of sales records. Each record is a dict with
+# "product", "units", and "price_per_unit".
+#
+# Complete the code so that:
+#   `revenue_list`  — a list of total revenue per record (units * price_per_unit)
+#                     for every record where units > 10
+#   `total_revenue` — the sum of all values in `revenue_list`
+#
+# Expected:
+#   revenue_list  == [270.0, 500.0, 880.0]
+#   total_revenue == 1650.0
+
+sales = [
+    {"product": "apple",  "units": 5,  "price_per_unit": 1.20},
+    {"product": "banana", "units": 15, "price_per_unit": 18.0},
+    {"product": "cherry", "units": 8,  "price_per_unit": 3.50},
+    {"product": "date",   "units": 20, "price_per_unit": 25.0},
+    {"product": "elderberry", "units": 40, "price_per_unit": 22.0},
+]
+
+revenue_list = []
+for record in sales:
+    pass  # replace with filter + revenue calculation
+
+total_revenue = ???

pythonlings/curriculum/exercises/lists/lists2.py

@@ -0,0 +1,13 @@
+# Exercise: Lists 2
+# I AM NOT DONE
+#
+# Fix the code below so that:
+#   - `first` holds the first element of `numbers` (should be 10)
+#   - the element at index 2 is changed from 30 to 99
+#
+# Only fix the two lines marked with ???.
+
+numbers = [10, 20, 30, 40, 50]
+
+first = numbers[???]
+numbers[???] = 99

pythonlings/curriculum/exercises/lists/lists3.py

@@ -0,0 +1,16 @@
+# Exercise: Lists 3
+# I AM NOT DONE
+#
+# Start with `items = ["apple", "banana"]`.
+# 1. Append "cherry" to the end of the list.
+# 2. Insert "mango" at index 1 (so it becomes the second element).
+# After both operations the list should be:
+#   ["apple", "mango", "banana", "cherry"]
+
+items = ["apple", "banana"]
+
+# Step 1: append "cherry"
+???
+
+# Step 2: insert "mango" at index 1
+???

pythonlings/curriculum/exercises/lists/lists4.py

@@ -0,0 +1,16 @@
+# Exercise: Lists 4
+# I AM NOT DONE
+#
+# Given `items = ["apple", "banana", "cherry", "date"]`:
+# 1. Remove "banana" from the list using `.remove()`.
+# 2. Pop the last element and store it in `last`.
+# After both operations `items` should be ["apple", "cherry"]
+# and `last` should be "date".
+
+items = ["apple", "banana", "cherry", "date"]
+
+# Step 1: remove "banana"
+???
+
+# Step 2: pop the last element into `last`
+last = ???

pythonlings/curriculum/exercises/lists/lists5.py

@@ -0,0 +1,16 @@
+# Exercise: Lists 5
+# I AM NOT DONE
+#
+# Given `letters = ["a", "b", "c", "d", "e", "f"]`, use slicing to
+# create three new lists:
+#   `first_three` — the first three elements: ["a", "b", "c"]
+#   `last_two`    — the last two elements:    ["e", "f"]
+#   `middle`      — elements at index 2 through 4 (inclusive): ["c", "d", "e"]
+#
+# Use slice notation (no loops, no indexing one element at a time).
+
+letters = ["a", "b", "c", "d", "e", "f"]
+
+first_three = letters[???]
+last_two    = letters[???]
+middle      = letters[???]