pythonlings 0.3.0__py3-none-any.whl

pythonlings/curriculum/exercises/collections/collections4.py

@@ -0,0 +1,26 @@
+# Exercise: Collections 4
+# -----------------------
+# I AM NOT DONE
+#
+# `defaultdict(list)` is great for grouping: every new key starts with
+# an empty list so you can append without checking first.
+#
+# Group the students below by their grade letter.
+# `by_grade` should be a `defaultdict(list)` where each key is a grade
+# letter and the value is a list of student names with that grade,
+# in the order they appear in `students`.
+
+from collections import defaultdict
+
+students = [
+    ("Alice", "A"),
+    ("Bob", "B"),
+    ("Carol", "A"),
+    ("Dave", "C"),
+    ("Eve", "B"),
+    ("Frank", "A"),
+]
+
+by_grade = ???
+for name, grade in students:
+    ???

pythonlings/curriculum/exercises/collections/collections5.py

@@ -0,0 +1,14 @@
+# Exercise: Collections 5
+# -----------------------
+# I AM NOT DONE
+#
+# `namedtuple` creates a lightweight class whose instances are tuples
+# with named fields — readable without index magic.
+#
+# Define a namedtuple type called `Point` with fields `x` and `y`.
+# Then create an instance `p` with x=3 and y=4.
+
+from collections import namedtuple
+
+Point = ???
+p = ???

pythonlings/curriculum/exercises/collections/collections6.py

@@ -0,0 +1,18 @@
+# Exercise: Collections 6
+# -----------------------
+# I AM NOT DONE
+#
+# Named-tuple fields can be accessed by name OR by index, just like a
+# regular tuple.  They also support `._replace()` to build a modified copy.
+#
+# A `Card` namedtuple with fields `rank` and `suit` is defined for you.
+# 1. Create `card` — the King of Spades (rank="K", suit="spades").
+# 2. Create `upgraded` by replacing the rank of `card` with "A"
+#    using `card._replace(...)`.
+
+from collections import namedtuple
+
+Card = namedtuple("Card", ["rank", "suit"])
+
+card = ???
+upgraded = ???

pythonlings/curriculum/exercises/collections/collections7.py

@@ -0,0 +1,20 @@
+# Exercise: Collections 7
+# -----------------------
+# I AM NOT DONE
+#
+# `deque` (double-ended queue) supports O(1) appends and pops from
+# BOTH ends — unlike a list, which is O(n) for the left end.
+#
+# Starting from an empty deque `d`:
+#   1. appendleft(1)   — push to the left
+#   2. append(2)       — push to the right
+#   3. appendleft(0)   — push to the left again
+#   4. Store the result of pop()       in `right_val`   (removes from right)
+#   5. Store the result of popleft()   in `left_val`    (removes from left)
+
+from collections import deque
+
+d = deque()
+???
+right_val = ???
+left_val = ???

pythonlings/curriculum/exercises/collections/collections8.py

@@ -0,0 +1,23 @@
+# Exercise: Collections 8
+# -----------------------
+# I AM NOT DONE
+#
+# A deque makes an efficient FIFO queue: enqueue with `append` (right)
+# and dequeue with `popleft` (left).
+#
+# Simulate a print queue:
+#   - Enqueue jobs "doc1", "doc2", "doc3" (in that order).
+#   - Dequeue them one by one into `first`, `second`, `third`.
+# The deque `queue` should be empty afterwards.
+
+from collections import deque
+
+queue = deque()
+
+# enqueue three jobs
+???
+
+# dequeue in FIFO order
+first = ???
+second = ???
+third = ???

pythonlings/curriculum/exercises/collections/collections9.py

@@ -0,0 +1,21 @@
+# Exercise: Collections 9
+# -----------------------
+# I AM NOT DONE
+#
+# Counter supports arithmetic:
+#   c1 + c2  — adds counts element-wise
+#   c1 - c2  — subtracts counts, dropping non-positive results
+#
+# Two inventory snapshots are given.
+# 1. Store in `combined`  the element-wise sum  of `monday` and `tuesday`.
+# 2. Store in `remainder` the result of subtracting `sold` from `combined`.
+#    (Only items with a positive remaining count are kept.)
+
+from collections import Counter
+
+monday  = Counter({"apple": 5, "banana": 3, "cherry": 2})
+tuesday = Counter({"apple": 2, "banana": 4, "date": 1})
+sold    = Counter({"apple": 4, "banana": 5, "cherry": 1})
+
+combined  = ???
+remainder = ???

pythonlings/curriculum/exercises/comprehensions/comprehensions1.py

@@ -0,0 +1,10 @@
+# Exercise: Comprehensions 1
+# I AM NOT DONE
+#
+# Use a list comprehension to build `numbers`: the integers 0 through 4
+# (i.e. 0, 1, 2, 3, 4) collected into a list.
+#
+# A list comprehension has the form: [expr for item in iterable]
+# Example: [x for x in range(3)]  →  [0, 1, 2]
+
+numbers = ???

pythonlings/curriculum/exercises/comprehensions/comprehensions10.py

@@ -0,0 +1,15 @@
+# Exercise: Comprehensions 10
+# I AM NOT DONE
+#
+# Build a lookup table `word_index` using a dict comprehension that maps each
+# word in `words` to its position (index) in the list.
+#
+# `enumerate(iterable)` yields (index, value) pairs — use it with a dict
+# comprehension to pair each word with its position:
+# {word: idx for idx, word in enumerate(words)}
+#
+# Expected: {"apple": 0, "banana": 1, "cherry": 2, "date": 3}
+
+words = ["apple", "banana", "cherry", "date"]
+
+word_index = ???

pythonlings/curriculum/exercises/comprehensions/comprehensions2.py

@@ -0,0 +1,12 @@
+# Exercise: Comprehensions 2
+# I AM NOT DONE
+#
+# Use a list comprehension with an `if` filter to build `evens`: only the
+# even numbers from `values`.
+#
+# A filtered comprehension: [expr for item in iterable if condition]
+# Example: [x for x in range(6) if x > 3]  →  [4, 5]
+
+values = [1, 2, 3, 4, 5, 6, 7, 8]
+
+evens = ???

pythonlings/curriculum/exercises/comprehensions/comprehensions3.py

@@ -0,0 +1,12 @@
+# Exercise: Comprehensions 3
+# I AM NOT DONE
+#
+# Use a list comprehension with a transform to build `doubled`: each number
+# in `values` multiplied by 2.
+#
+# Transform the expression, not just the item:
+# Example: [x * 3 for x in [1, 2, 3]]  →  [3, 6, 9]
+
+values = [1, 2, 3, 4, 5]
+
+doubled = ???

pythonlings/curriculum/exercises/comprehensions/comprehensions4.py

@@ -0,0 +1,14 @@
+# Exercise: Comprehensions 4
+# I AM NOT DONE
+#
+# Use a list comprehension with two `for` clauses (a nested loop) to build
+# `pairs`: every (row, col) tuple where row is in `rows` and col is in `cols`.
+#
+# Nested-loop comprehension: [expr for a in A for b in B]
+# Example: [(x, y) for x in [1, 2] for y in ['a', 'b']]
+#   →  [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')]
+
+rows = [0, 1]
+cols = [0, 1, 2]
+
+pairs = ???

pythonlings/curriculum/exercises/comprehensions/comprehensions5.py

@@ -0,0 +1,12 @@
+# Exercise: Comprehensions 5
+# I AM NOT DONE
+#
+# Use a dict comprehension to build `squared`: a mapping from each number in
+# `numbers` to its square.
+#
+# A dict comprehension: {key_expr: val_expr for item in iterable}
+# Example: {x: x**2 for x in [1, 2, 3]}  →  {1: 1, 2: 4, 3: 9}
+
+numbers = [1, 2, 3, 4, 5]
+
+squared = ???

pythonlings/curriculum/exercises/comprehensions/comprehensions6.py

@@ -0,0 +1,12 @@
+# Exercise: Comprehensions 6
+# I AM NOT DONE
+#
+# Use a set comprehension to build `unique_lengths`: the set of distinct word
+# lengths in `words`.
+#
+# A set comprehension: {expr for item in iterable}
+# Example: {len(w) for w in ["hi", "hey", "yo"]}  →  {2, 3}
+
+words = ["apple", "bat", "car", "dog", "elephant", "fig"]
+
+unique_lengths = ???

pythonlings/curriculum/exercises/comprehensions/comprehensions7.py

@@ -0,0 +1,12 @@
+# Exercise: Comprehensions 7
+# I AM NOT DONE
+#
+# Use a list comprehension over the characters of a string to build `vowels`:
+# a list of every vowel (a, e, i, o, u) found in `sentence` (lowercase).
+#
+# You can iterate over a string character by character:
+# Example: [c for c in "hello" if c in "aeiou"]  →  ['e', 'o']
+
+sentence = "list comprehensions are quite powerful"
+
+vowels = ???

pythonlings/curriculum/exercises/comprehensions/comprehensions8.py

@@ -0,0 +1,15 @@
+# Exercise: Comprehensions 8
+# I AM NOT DONE
+#
+# Use a list comprehension with a conditional expression (ternary) to build
+# `labels`: for each number in `values`, use "even" if the number is even,
+# otherwise use "odd".
+#
+# Conditional expression inside a comprehension:
+# [value_if_true if condition else value_if_false for item in iterable]
+# Example: ["pos" if x > 0 else "non-pos" for x in [-1, 2, 0]]
+#   →  ['non-pos', 'pos', 'non-pos']
+
+values = [1, 2, 3, 4, 5, 6]
+
+labels = ???

pythonlings/curriculum/exercises/comprehensions/comprehensions9.py

@@ -0,0 +1,13 @@
+# Exercise: Comprehensions 9
+# I AM NOT DONE
+#
+# Use a list comprehension to flatten `matrix` (a list of lists) into a single
+# list called `flat`.
+#
+# Flattening with a comprehension uses two `for` clauses:
+# [item for sublist in outer for item in sublist]
+# Example: [[1, 2], [3, 4]]  →  [1, 2, 3, 4]
+
+matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+
+flat = ???

pythonlings/curriculum/exercises/conditionals/conditionals1.py

@@ -0,0 +1,15 @@
+# Exercise: Conditionals 1
+# I AM NOT DONE
+#
+# Python's simplest conditional: if the condition is True, the indented
+# block runs; otherwise nothing happens.
+#
+# `is_sunny` is True. Write an `if` statement so that `message` is set
+# to "Let's go outside!" when `is_sunny` is True.
+# Leave `message` as the empty string "" before the if-block.
+
+is_sunny = True
+message = ""
+
+if ???:
+    message = "Let's go outside!"

pythonlings/curriculum/exercises/conditionals/conditionals10.py

@@ -0,0 +1,18 @@
+# Exercise: Conditionals 10
+# I AM NOT DONE
+#
+# Putting it all together: classify a number using several conditions.
+#
+# Complete `classify(n)` so it returns:
+#   "large positive"   when n > 100
+#   "small positive"   when n > 0  (and not > 100)
+#   "zero"             when n == 0
+#   "small negative"   when n >= -100  (and not 0 or positive)
+#   "large negative"   when n < -100
+#
+# Use an if / elif / elif / elif / else chain.
+
+def classify(n):
+    if ???:
+        return "large positive"
+    ???

pythonlings/curriculum/exercises/conditionals/conditionals2.py

@@ -0,0 +1,13 @@
+# Exercise: Conditionals 2
+# I AM NOT DONE
+#
+# An if/else gives two branches: one when the condition is True,
+# another when it is False.
+#
+# Complete the function `sign(n)` so it returns "positive" when n > 0
+# and "non-positive" otherwise.
+
+def sign(n):
+    if n > 0:
+        return "positive"
+    ???

pythonlings/curriculum/exercises/conditionals/conditionals3.py

@@ -0,0 +1,18 @@
+# Exercise: Conditionals 3
+# I AM NOT DONE
+#
+# `elif` lets you chain multiple conditions.  Python tests them in order
+# and runs the first branch whose condition is True.
+#
+# Complete `grade(score)` so it returns:
+#   "A" for score >= 90
+#   "B" for score >= 80
+#   "C" for score >= 70
+#   "F" for anything below 70
+
+def grade(score):
+    if score >= 90:
+        return "A"
+    # add the remaining elif / else branches
+
+    return "F"

pythonlings/curriculum/exercises/conditionals/conditionals4.py

@@ -0,0 +1,20 @@
+# Exercise: Conditionals 4
+# I AM NOT DONE
+#
+# Python comparison operators: <, <=, >, >=, ==, !=
+#   ==  equal to          !=  not equal to
+#   <   less than         <=  less than or equal
+#   >   greater than      >=  greater than or equal
+#
+# Complete `compare(a, b)` so it returns:
+#   "less"    when a < b
+#   "equal"   when a == b
+#   "greater" when a > b
+
+def compare(a, b):
+    if a ??? b:
+        return "less"
+    elif a ??? b:
+        return "equal"
+    else:
+        return "greater"

pythonlings/curriculum/exercises/conditionals/conditionals5.py

@@ -0,0 +1,17 @@
+# Exercise: Conditionals 5
+# I AM NOT DONE
+#
+# Boolean operators combine conditions:
+#   `and` — True only when BOTH sides are True
+#   `or`  — True when AT LEAST ONE side is True
+#
+# Complete `can_ride(height, has_ticket)` so it returns True only when
+# the rider is at least 120 cm tall AND has a ticket.
+# Complete `gets_discount(is_student, is_senior)` so it returns True
+# when the person is a student OR a senior.
+
+def can_ride(height, has_ticket):
+    return height >= 120 ??? has_ticket
+
+def gets_discount(is_student, is_senior):
+    return is_student ??? is_senior

pythonlings/curriculum/exercises/conditionals/conditionals6.py

@@ -0,0 +1,15 @@
+# Exercise: Conditionals 6
+# I AM NOT DONE
+#
+# `not` flips a boolean: `not True` is False, `not False` is True.
+# It is useful when you want to act on the absence of something.
+#
+# Complete `is_closed(is_open)` so it returns True when the shop is NOT open.
+# Complete `neither_zero(a, b)` so it returns True when NEITHER a nor b is 0.
+# Hint: use `not` in both functions.
+
+def is_closed(is_open):
+    return ???
+
+def neither_zero(a, b):
+    return ???

pythonlings/curriculum/exercises/conditionals/conditionals7.py

@@ -0,0 +1,18 @@
+# Exercise: Conditionals 7
+# I AM NOT DONE
+#
+# Nested `if` statements let you check a second condition only after
+# a first condition has already passed.
+#
+# Complete `ticket_price(age, is_member)` using nested if/else:
+#   - Under 5 years old  => free (0)
+#   - 5 or older AND a member => 8
+#   - 5 or older AND NOT a member => 12
+
+def ticket_price(age, is_member):
+    if age < 5:
+        return 0
+    else:
+        if ???:
+            return 8
+        ???

pythonlings/curriculum/exercises/conditionals/conditionals8.py

@@ -0,0 +1,20 @@
+# Exercise: Conditionals 8
+# I AM NOT DONE
+#
+# Python has "truthiness": values can be used directly in conditions
+# without an explicit == check.
+#
+# Falsy values (treated as False in a condition):
+#   0, 0.0, "", [], {}, None
+# Everything else is truthy.
+#
+# Complete `describe(value)` so it returns:
+#   "empty" when value is falsy
+#   "has content" when value is truthy
+#
+# Do NOT use == in your condition — use `if value` directly.
+
+def describe(value):
+    if ???:
+        return "has content"
+    ???

pythonlings/curriculum/exercises/conditionals/conditionals9.py

@@ -0,0 +1,12 @@
+# Exercise: Conditionals 9
+# I AM NOT DONE
+#
+# The ternary (conditional) expression lets you pick a value in one line:
+#
+#   result = value_if_true if condition else value_if_false
+#
+# Complete `absolute(n)` so it returns n when n >= 0, and -n otherwise.
+# Write it as a single return statement using a ternary expression.
+
+def absolute(n):
+    return ???

pythonlings/curriculum/exercises/context_managers/context_managers1.py

@@ -0,0 +1,18 @@
+# Exercise: Context Managers 1
+# I AM NOT DONE
+#
+# Use a `with` statement to open `data_path` for writing and write the
+# text "hello, context!" to it.  The with-block should handle opening
+# and closing automatically — do NOT call .close() yourself.
+#
+# Hint: `with open(path, "w") as f:` opens the file; call `f.write(text)`
+# inside the block.
+
+import tempfile
+
+data_path = tempfile.mktemp()
+
+# Replace the bare open/write/close below with a with-statement.
+f = open(data_path, "w")
+f.write("hello, context!")
+# Bug: .close() is missing — but the real fix is to use `with`.

pythonlings/curriculum/exercises/context_managers/context_managers2.py

@@ -0,0 +1,19 @@
+# Exercise: Context Managers 2
+# I AM NOT DONE
+#
+# After the with-block finishes, the file object should be closed
+# automatically.  The code below opens a file WITHOUT a with-statement,
+# so `f.closed` is False after the write.
+#
+# Fix it: replace the bare open/write/close sequence with a with-statement
+# that opens `data_path` for writing and writes "closed check".
+# After the with-block, `f` must be the file object and `f.closed` must be True.
+
+import tempfile
+
+data_path = tempfile.mktemp()
+
+# Bug: no with-statement — the file stays open until garbage-collected.
+f = open(data_path, "w")
+f.write("closed check")
+# .close() is intentionally omitted to illustrate the problem.

pythonlings/curriculum/exercises/context_managers/context_managers3.py

@@ -0,0 +1,24 @@
+# Exercise: Context Managers 3
+# I AM NOT DONE
+#
+# Give the `Timer` class context-manager support so `with Timer() as t:`
+# works.
+#
+# * `__enter__` must return the instance (self).
+# * `__exit__` must set `self.finished` to True.
+# Both methods take the standard three exception parameters after self.
+#
+# Hint: `def __exit__(self, exc_type, exc_val, exc_tb):` — set the flag,
+# then return None (or False) so exceptions propagate normally.
+
+
+class Timer:
+    def __init__(self):
+        self.finished = False
+
+    # Bug: __enter__ and __exit__ are missing — add them.
+
+
+t = Timer()
+with t:
+    pass

pythonlings/curriculum/exercises/context_managers/context_managers4.py

@@ -0,0 +1,30 @@
+# Exercise: Context Managers 4
+# I AM NOT DONE
+#
+# `ManagedList` wraps a list and uses `__exit__` to do cleanup.
+# When the with-block exits normally, `__exit__` should append the
+# string "done" to `self.log`.
+#
+# The `__enter__` method is already written.  Complete `__exit__` so
+# that it appends "done" to `self.log` and returns None.
+#
+# Hint: `def __exit__(self, exc_type, exc_val, exc_tb): self.log.append("done")`
+
+
+class ManagedList:
+    def __init__(self):
+        self.items = []
+        self.log = []
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        # Bug: cleanup is missing — append "done" to self.log.
+        pass
+
+
+ml = ManagedList()
+with ml as resource:
+    resource.items.append(1)
+    resource.items.append(2)

pythonlings/curriculum/exercises/context_managers/context_managers5.py

@@ -0,0 +1,30 @@
+# Exercise: Context Managers 5
+# I AM NOT DONE
+#
+# `__enter__` can return any value; that value becomes the target of the
+# `as` clause.  Fix `DatabaseConnection` so that `with db as conn:` gives
+# the caller a dict that they can use like a connection.
+#
+# `__enter__` should return `self.connection` (the dict already set up in
+# `__init__`).  `__exit__` should set `self.open` to False.
+#
+# Hint: `def __enter__(self): return self.connection`
+
+
+class DatabaseConnection:
+    def __init__(self, dsn):
+        self.dsn = dsn
+        self.open = True
+        self.connection = {"dsn": dsn, "active": True}
+
+    def __enter__(self):
+        # Bug: returns None instead of self.connection.
+        return None
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.open = False
+
+
+db = DatabaseConnection("sqlite:///:memory:")
+with db as conn:
+    result = conn

pythonlings/curriculum/exercises/context_managers/context_managers6.py

@@ -0,0 +1,26 @@
+# Exercise: Context Managers 6
+# I AM NOT DONE
+#
+# `contextlib.contextmanager` turns a generator function into a context
+# manager.  Write the body of `managed_counter` so it:
+#   1. Creates a list `counter = []` before the yield.
+#   2. Yields `counter` (the `as` target gets this list).
+#   3. Appends the string "finished" to `counter` after the yield.
+#
+# The `@contextmanager` decorator and the function signature are already
+# provided.  Only fill in the body.
+#
+# Hint: everything before `yield` is __enter__; everything after is __exit__.
+
+from contextlib import contextmanager
+
+
+@contextmanager
+def managed_counter():
+    # Bug: body is missing — add counter, yield, then cleanup.
+    pass
+
+
+with managed_counter() as counter:
+    counter.append(1)
+    counter.append(2)

pythonlings/curriculum/exercises/context_managers/context_managers7.py

@@ -0,0 +1,30 @@
+# Exercise: Context Managers 7
+# I AM NOT DONE
+#
+# `__exit__` can suppress exceptions by returning True.  Complete
+# `SilentZeroDivision` so that any ZeroDivisionError raised inside
+# the with-block is silently swallowed (execution continues after
+# the with-block as if no exception occurred).
+#
+# * If `exc_type` is `ZeroDivisionError`, return True (suppress it).
+# * For every other exception (or no exception), return None (propagate).
+#
+# Hint: `if exc_type is ZeroDivisionError: return True`
+
+
+class SilentZeroDivision:
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        # Bug: always returns None, so ZeroDivisionError is not suppressed.
+        return None
+
+
+result = "not set"
+with SilentZeroDivision():
+    result = 1 / 0        # should be suppressed
+    result = "unreachable"
+
+# If suppression works, `result` stays "not set" because the exception
+# aborts the rest of the block body before the second assignment.