pythonlings 0.3.0__py3-none-any.whl

pythonlings/curriculum/exercises/dictionaries/dictionaries6.py

@@ -0,0 +1,18 @@
+# Exercise: Dictionaries 6
+# I AM NOT DONE
+#
+# `.get(key, default)` returns the value for a key if it exists,
+# or the default if the key is missing — without raising a KeyError.
+#
+# Given `config` below:
+#   `timeout`  — get "timeout" with a default of 30
+#   `retries`  — get "retries" with a default of 3
+#   `verbose`  — get "verbose" with a default of False
+#
+# "timeout" exists in config, "retries" and "verbose" do not.
+
+config = {"host": "localhost", "port": 8080, "timeout": 60}
+
+timeout = ???
+retries = ???
+verbose = ???

pythonlings/curriculum/exercises/dictionaries/dictionaries7.py

@@ -0,0 +1,17 @@
+# Exercise: Dictionaries 7
+# I AM NOT DONE
+#
+# Iterate over a dictionary to compute a summary.
+#
+# Given `prices` below, build `discounted` — a new dict where every
+# value is reduced by 10% (multiply each price by 0.9).
+# Round each result to 2 decimal places.
+#
+# Expected:
+#   discounted == {"apple": 0.9, "milk": 1.35, "bread": 2.25}
+
+prices = {"apple": 1.0, "milk": 1.5, "bread": 2.5}
+
+discounted = {}
+for ???:
+    ???

pythonlings/curriculum/exercises/dictionaries/dictionaries8.py

@@ -0,0 +1,17 @@
+# Exercise: Dictionaries 8
+# I AM NOT DONE
+#
+# Use the `in` operator to test key membership in a dict.
+#
+# Given `permissions` below, set:
+#   `can_read`    — True if "read"   is a key in permissions, False otherwise
+#   `can_write`   — True if "write"  is a key in permissions, False otherwise
+#   `can_delete`  — True if "delete" is a key in permissions, False otherwise
+#
+# Do NOT hard-code True/False — use `in` expressions.
+
+permissions = {"read": True, "write": False}
+
+can_read = ???
+can_write = ???
+can_delete = ???

pythonlings/curriculum/exercises/dictionaries/dictionaries9.py

@@ -0,0 +1,25 @@
+# Exercise: Dictionaries 9
+# I AM NOT DONE
+#
+# A nested dict is a dict whose values are themselves dicts.
+#
+# Given `school` below, set:
+#   `alice_grade` — Alice's grade (school["students"]["alice"]["grade"])
+#   `math_room`   — the room number for math  (school["courses"]["math"]["room"])
+#   `num_students` — the total enrollment count (school["meta"]["enrollment"])
+
+school = {
+    "students": {
+        "alice": {"grade": "A", "age": 20},
+        "bob":   {"grade": "B", "age": 22},
+    },
+    "courses": {
+        "math":    {"room": 101, "credits": 3},
+        "english": {"room": 205, "credits": 3},
+    },
+    "meta": {"enrollment": 350, "founded": 1990},
+}
+
+alice_grade = ???
+math_room = ???
+num_students = ???

pythonlings/curriculum/exercises/enums/enums1.py

@@ -0,0 +1,12 @@
+# Exercise: Enums 1
+# I AM NOT DONE
+#
+# Goal: Define Color members with string values and choose RED.
+
+from enum import Enum
+
+class Color(Enum):
+    RED = ???
+    BLUE = ???
+
+favorite = Color.RED

pythonlings/curriculum/exercises/enums/enums2.py

@@ -0,0 +1,11 @@
+# Exercise: Enums 2
+# I AM NOT DONE
+#
+# Goal: Use auto() for three task statuses.
+
+from enum import Enum, auto
+
+class Status(Enum):
+    TODO = ???
+    DOING = ???
+    DONE = ???

pythonlings/curriculum/exercises/enums/enums3.py

@@ -0,0 +1,14 @@
+# Exercise: Enums 3
+# I AM NOT DONE
+#
+# Goal: Read an enum member's name and value.
+
+from enum import Enum
+
+class Priority(Enum):
+    LOW = 1
+    HIGH = 5
+
+selected = Priority.HIGH
+selected_name = ???
+selected_value = ???

pythonlings/curriculum/exercises/enums/enums4.py

@@ -0,0 +1,13 @@
+# Exercise: Enums 4
+# I AM NOT DONE
+#
+# Goal: Iterate over an enum to collect its values.
+
+from enum import Enum
+
+class Size(Enum):
+    SMALL = "S"
+    MEDIUM = "M"
+    LARGE = "L"
+
+size_codes = ???

pythonlings/curriculum/exercises/enums/enums5.py

@@ -0,0 +1,14 @@
+# Exercise: Enums 5
+# I AM NOT DONE
+#
+# Goal: Return True only for terminal ticket states.
+
+from enum import Enum, auto
+
+class TicketState(Enum):
+    OPEN = auto()
+    CLOSED = auto()
+    CANCELLED = auto()
+
+def is_terminal(state):
+    return ???

pythonlings/curriculum/exercises/enums/enums6.py

@@ -0,0 +1,15 @@
+# Exercise: Enums 6
+# I AM NOT DONE
+#
+# Goal: Give each Direction member a delta tuple and return it from a method.
+
+from enum import Enum
+
+class Direction(Enum):
+    NORTH = (0, -1)
+    SOUTH = (0, 1)
+    EAST = (1, 0)
+    WEST = (-1, 0)
+
+    def delta(self):
+        return ???

pythonlings/curriculum/exercises/exceptions/exceptions1.py

@@ -0,0 +1,15 @@
+# Exercise: Exceptions 1
+# I AM NOT DONE
+#
+# Complete safe_divide(a, b) so that dividing by zero is caught and
+# the function returns the string "error" instead of crashing.
+# A normal division should return the numeric result.
+#
+# Wrap the body in a try/except block:
+#   try:
+#       ...
+#   except ZeroDivisionError:
+#       ...
+
+def safe_divide(a, b):
+    return a / b

pythonlings/curriculum/exercises/exceptions/exceptions10.py

@@ -0,0 +1,19 @@
+# Exercise: Exceptions 10
+# I AM NOT DONE
+#
+# Complete validate_username(name) which enforces three rules:
+#   1. The name must be a str; if not, raise TypeError("username must be a str").
+#   2. The name must be between 3 and 20 characters (inclusive); if not,
+#      raise ValueError("username must be 3–20 characters").
+#   3. The name must contain only letters and digits (name.isalnum()); if not,
+#      raise ValueError("username must be alphanumeric").
+#
+# On success, return name.lower().
+#
+# Check the rules in the order listed above.
+
+def validate_username(name):
+    # TODO: check type (raise TypeError if not str)
+    # TODO: check length (raise ValueError if out of 3–20 range)
+    # TODO: check alphanumeric (raise ValueError if not .isalnum())
+    return name.lower()

pythonlings/curriculum/exercises/exceptions/exceptions2.py

@@ -0,0 +1,12 @@
+# Exercise: Exceptions 2
+# I AM NOT DONE
+#
+# Complete parse_number(s) so that it converts the string `s` to an int
+# and returns it. If `s` cannot be converted (i.e. int(s) raises a
+# ValueError), return -1 instead.
+#
+# Catch the *specific* exception:
+#   except ValueError:
+
+def parse_number(s):
+    return int(s)

pythonlings/curriculum/exercises/exceptions/exceptions3.py

@@ -0,0 +1,13 @@
+# Exercise: Exceptions 3
+# I AM NOT DONE
+#
+# Complete describe_error(s) so that it tries to convert `s` to a float,
+# returning the float on success.  On failure it should return the string
+# representation of the exception message (i.e. str(e)), NOT a fixed string.
+#
+# Capture the exception object with `as`:
+#   except ValueError as e:
+#       return str(e)
+
+def describe_error(s):
+    return float(s)

pythonlings/curriculum/exercises/exceptions/exceptions4.py

@@ -0,0 +1,17 @@
+# Exercise: Exceptions 4
+# I AM NOT DONE
+#
+# Complete load_value(data, key) so it uses a try/except/else block:
+#   - try to retrieve data[key]
+#   - if a KeyError occurs, return the string "missing"
+#   - in the else clause (runs only when no exception occurred),
+#     return the value doubled (value * 2)
+#
+# The else clause of a try block runs when NO exception was raised.
+
+def load_value(data, key):
+    try:
+        value = data[key]
+    except KeyError:
+        return "missing"
+    # TODO: add an else clause here that returns value * 2

pythonlings/curriculum/exercises/exceptions/exceptions5.py

@@ -0,0 +1,20 @@
+# Exercise: Exceptions 5
+# I AM NOT DONE
+#
+# Complete read_first(items) using a try/finally block.
+# - Try to return items[0].
+# - If items is empty (IndexError), return None.
+# - In the finally clause, append the string "done" to the module-level
+#   list `log` — this must happen whether or not an exception occurred.
+#
+# The finally clause runs ALWAYS, even when an exception is raised or
+# a return is executed in the try block.
+
+log = []
+
+def read_first(items):
+    try:
+        return items[0]
+    except IndexError:
+        return None
+    # TODO: add a finally clause that does log.append("done")

pythonlings/curriculum/exercises/exceptions/exceptions6.py

@@ -0,0 +1,13 @@
+# Exercise: Exceptions 6
+# I AM NOT DONE
+#
+# Complete require_positive(n) so that:
+# - If n is greater than 0, return n.
+# - Otherwise, raise a ValueError.
+#
+# Use the `raise` statement to throw an exception:
+#   raise ValueError
+
+def require_positive(n):
+    # TODO: raise ValueError when n is not positive
+    return n

pythonlings/curriculum/exercises/exceptions/exceptions7.py

@@ -0,0 +1,15 @@
+# Exercise: Exceptions 7
+# I AM NOT DONE
+#
+# Complete check_age(age) so that:
+# - If age is between 0 and 120 (inclusive), return age.
+# - Otherwise, raise a ValueError with the message:
+#   "age must be between 0 and 120"
+#
+# Pass a message string when raising:
+#   raise ValueError("your message here")
+
+def check_age(age):
+    # TODO: raise ValueError with the message "age must be between 0 and 120"
+    # when age is out of range
+    return age

pythonlings/curriculum/exercises/exceptions/exceptions8.py

@@ -0,0 +1,17 @@
+# Exercise: Exceptions 8
+# I AM NOT DONE
+#
+# Complete classify_error(func) so that it calls func() with no arguments
+# and returns a string describing what happened:
+#   - If no exception: return "ok"
+#   - If a ValueError:  return "value error"
+#   - If a TypeError:   return "type error"
+#   - If any other exception: return "other error"
+#
+# Use multiple except clauses — each clause catches a different exception type.
+
+def classify_error(func):
+    try:
+        func()
+        return "ok"
+    # TODO: add except clauses for ValueError, TypeError, and a catch-all

pythonlings/curriculum/exercises/exceptions/exceptions9.py

@@ -0,0 +1,20 @@
+# Exercise: Exceptions 9
+# I AM NOT DONE
+#
+# Define a custom exception class called `InsufficientFundsError` that
+# inherits from Exception.
+#
+# Then complete withdraw(balance, amount) so that:
+# - If amount > balance, raise InsufficientFundsError with the message:
+#   "cannot withdraw <amount> from balance of <balance>"
+# - Otherwise return balance - amount.
+#
+# A custom exception class looks like:
+#   class MyError(Exception):
+#       pass
+
+# TODO: define InsufficientFundsError here
+
+def withdraw(balance, amount):
+    # TODO: raise InsufficientFundsError when amount > balance
+    return balance - amount

pythonlings/curriculum/exercises/file_io/file_io1.py

@@ -0,0 +1,18 @@
+# Exercise: File IO 1
+# I AM NOT DONE
+#
+# `data_path` is an absolute path to a new temp file.
+# Write the string "hello, file!" to that file using open() and .write().
+# The file should contain exactly that text after you are done.
+#
+# Hint: open(path, "w") returns a file object; call .write(text) on it,
+# then .close() it — or use a with statement.
+
+import tempfile
+
+data_path = tempfile.mktemp()
+
+# Write "hello, file!" to data_path.
+f = open(data_path, "w")
+f.write(???)
+f.close()

pythonlings/curriculum/exercises/file_io/file_io10.py

@@ -0,0 +1,25 @@
+# Exercise: File IO 10
+# I AM NOT DONE
+#
+# `src_path` contains three lines of mixed-case text.
+# Copy the file to `dst_path`, converting every line to UPPERCASE.
+# After your code runs, `dst_path` should contain the uppercased text.
+#
+# Steps:
+#   1. Open src_path for reading.
+#   2. Open dst_path for writing.
+#   3. For each line read from src, write line.upper() to dst.
+
+import tempfile
+
+src_path = tempfile.mktemp()
+dst_path = tempfile.mktemp()
+
+with open(src_path, "w") as f:
+    f.write("hello world\npython is fun\nfile io rocks\n")
+
+# Copy src_path to dst_path, converting each line to uppercase.
+with open(src_path) as src:
+    with open(dst_path, "w") as dst:
+        for line in src:
+            dst.write(line)   # TODO: write line.upper() instead of line

pythonlings/curriculum/exercises/file_io/file_io2.py

@@ -0,0 +1,16 @@
+# Exercise: File IO 2
+# I AM NOT DONE
+#
+# `note_path` points to a file that already contains the text "remember".
+# Read the WHOLE file and store its text in the variable `contents`.
+#
+# Hint: open(path).read() returns the entire file as a string.
+
+import tempfile
+
+note_path = tempfile.mktemp()
+with open(note_path, "w") as f:
+    f.write("remember")
+
+# Read the whole file into `contents`.
+contents = ???

pythonlings/curriculum/exercises/file_io/file_io3.py

@@ -0,0 +1,18 @@
+# Exercise: File IO 3
+# I AM NOT DONE
+#
+# Use a `with` statement to open `log_path` for writing ("w") and write
+# the string "first entry" to it.  The `with` statement closes the file
+# automatically when its block ends.
+#
+# Pattern:
+#   with open(path, "w") as fh:
+#       fh.write(text)
+
+import tempfile
+
+log_path = tempfile.mktemp()
+
+# Replace the ??? so the with-block writes "first entry".
+with open(log_path, "w") as fh:
+    fh.write(???)

pythonlings/curriculum/exercises/file_io/file_io4.py

@@ -0,0 +1,21 @@
+# Exercise: File IO 4
+# I AM NOT DONE
+#
+# `poem_path` already contains three lines:
+#   "roses are red\n"
+#   "violets are blue\n"
+#   "python is great\n"
+#
+# Read ALL lines from the file and store them in the variable `lines`
+# as a list of strings (newlines included, as .readlines() returns them).
+#
+# Hint: open(path).readlines() returns a list of lines.
+
+import tempfile
+
+poem_path = tempfile.mktemp()
+with open(poem_path, "w") as f:
+    f.write("roses are red\nviolets are blue\npython is great\n")
+
+# Read all lines into `lines`.
+lines = open(poem_path).read()   # TODO: use .readlines() instead of .read()

pythonlings/curriculum/exercises/file_io/file_io5.py

@@ -0,0 +1,19 @@
+# Exercise: File IO 5
+# I AM NOT DONE
+#
+# `journal_path` already has the line "day 1: sunny\n" written to it.
+# Open the same file in APPEND mode ("a") and write "day 2: rainy\n"
+# so that both lines are present in the file.
+#
+# Append mode adds content after what already exists without erasing it.
+# Using "w" would overwrite and lose the first line — use "a" instead.
+
+import tempfile
+
+journal_path = tempfile.mktemp()
+with open(journal_path, "w") as f:
+    f.write("day 1: sunny\n")
+
+# Append "day 2: rainy\n" to journal_path.
+with open(journal_path, "w") as fh:   # TODO: change "w" to "a"
+    fh.write("day 2: rainy\n")

pythonlings/curriculum/exercises/file_io/file_io6.py

@@ -0,0 +1,22 @@
+# Exercise: File IO 6
+# I AM NOT DONE
+#
+# `numbers_path` contains five numbers, one per line:
+#   10, 20, 30, 40, 50
+#
+# Iterate over the lines of the file (using `for line in fh:`) and build
+# `total` as the sum of the integer values.
+#
+# Hint: int(line.strip()) converts a line like "10\n" to the integer 10.
+
+import tempfile
+
+numbers_path = tempfile.mktemp()
+with open(numbers_path, "w") as f:
+    f.write("10\n20\n30\n40\n50\n")
+
+total = 0
+# Iterate over the file's lines and add each integer value to total.
+with open(numbers_path) as fh:
+    for line in fh:
+        total += line   # TODO: convert line to int first (strip whitespace)

pythonlings/curriculum/exercises/file_io/file_io7.py

@@ -0,0 +1,20 @@
+# Exercise: File IO 7
+# I AM NOT DONE
+#
+# You have a list of strings called `words`.
+# Write them to `words_path` so that each word appears on its own line.
+# The file should contain exactly:
+#   "alpha\nbeta\ngamma\n"
+#
+# Hint: fh.writelines(iterable) writes each item without adding newlines,
+# so you need to ensure each string ends with "\n" before passing them in.
+# Alternatively, use a loop: for w in words: fh.write(w + "\n")
+
+import tempfile
+
+words_path = tempfile.mktemp()
+words = ["alpha", "beta", "gamma"]
+
+# Write each word to words_path on its own line.
+with open(words_path, "w") as fh:
+    fh.writelines(words)   # TODO: each word needs a newline at the end

pythonlings/curriculum/exercises/file_io/file_io8.py

@@ -0,0 +1,18 @@
+# Exercise: File IO 8
+# I AM NOT DONE
+#
+# `source_path` contains the text "  Hello, World!  " (with surrounding spaces).
+# Read the file, strip the leading/trailing whitespace from the content,
+# and store the cleaned text in `result`.
+#
+# Hint: str.strip() removes surrounding whitespace from a string.
+
+import tempfile
+
+source_path = tempfile.mktemp()
+with open(source_path, "w") as f:
+    f.write("  Hello, World!  ")
+
+# Read the file and strip whitespace; store in `result`.
+with open(source_path) as fh:
+    result = fh.read()   # TODO: call .strip() on the result

pythonlings/curriculum/exercises/file_io/file_io9.py

@@ -0,0 +1,19 @@
+# Exercise: File IO 9
+# I AM NOT DONE
+#
+# `essay_path` contains a short text with multiple words.
+# Count the total number of words in the file and store the count in
+# the variable `word_count`.
+#
+# A word is any whitespace-separated token — str.split() with no
+# argument splits on any whitespace and discards empty strings.
+
+import tempfile
+
+essay_path = tempfile.mktemp()
+with open(essay_path, "w") as f:
+    f.write("the quick brown fox jumps over the lazy dog")
+
+# Count the words in essay_path and store in `word_count`.
+with open(essay_path) as fh:
+    word_count = len(fh.read())   # TODO: split into words before taking len()

pythonlings/curriculum/exercises/functional/functional1.py

@@ -0,0 +1,7 @@
+# Exercise: Functional 1
+# I AM NOT DONE
+#
+# Assign a lambda to `square` that takes one number and returns its square.
+# A lambda is written as:  lambda <arg>: <expression>
+
+square = ???

pythonlings/curriculum/exercises/functional/functional10.py

@@ -0,0 +1,19 @@
+# Exercise: Functional 10
+# I AM NOT DONE
+#
+# Build a small data-processing pipeline using map, filter, and reduce.
+#
+# Given a list of raw scores (integers), compute `result` as follows:
+#   Step 1 — map:    multiply every score by 2  (use map + lambda)
+#   Step 2 — filter: keep only scores > 10      (use filter + lambda)
+#   Step 3 — reduce: sum the remaining scores   (use reduce + lambda)
+#
+# Replace each ??? with the correct lambda.
+
+from functools import reduce
+
+scores = [1, 3, 6, 2, 8, 4]
+
+doubled = list(map(???, scores))
+above_ten = list(filter(???, doubled))
+result = reduce(???, above_ten)

pythonlings/curriculum/exercises/functional/functional2.py

@@ -0,0 +1,8 @@
+# Exercise: Functional 2
+# I AM NOT DONE
+#
+# Assign a lambda to `absolute` that takes one number and returns its
+# absolute value — WITHOUT using the built-in `abs()` function.
+# Use a conditional expression:  x if x >= 0 else -x
+
+absolute = ???

pythonlings/curriculum/exercises/functional/functional3.py

@@ -0,0 +1,11 @@
+# Exercise: Functional 3
+# I AM NOT DONE
+#
+# Use `map()` to build `doubled` — a list where every number in `numbers`
+# is multiplied by 2.
+# `map(func, iterable)` applies `func` to each element.
+# Remember to wrap the result in `list(...)`.
+
+numbers = [1, 2, 3, 4, 5]
+
+doubled = list(map(???, numbers))

pythonlings/curriculum/exercises/functional/functional4.py

@@ -0,0 +1,11 @@
+# Exercise: Functional 4
+# I AM NOT DONE
+#
+# Use `filter()` to build `evens` — a list containing only the even numbers
+# from `numbers`.
+# `filter(func, iterable)` keeps elements where `func(element)` is truthy.
+# Remember to wrap the result in `list(...)`.
+
+numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+evens = list(filter(???, numbers))

pythonlings/curriculum/exercises/functional/functional5.py

@@ -0,0 +1,11 @@
+# Exercise: Functional 5
+# I AM NOT DONE
+#
+# Sort `words` by the LENGTH of each word (shortest first).
+# Use `sorted()` with the `key=` parameter.
+# The key function receives one word and should return its length.
+# Replace ??? with a lambda that returns the length of a word.
+
+words = ["banana", "fig", "apple", "kiwi", "date"]
+
+by_length = sorted(words, key=???)

pythonlings/curriculum/exercises/functional/functional6.py

@@ -0,0 +1,14 @@
+# Exercise: Functional 6
+# I AM NOT DONE
+#
+# `apply_twice` should call `func` on `value`, then call `func` on that result.
+# In other words: apply_twice(f, x) → f(f(x))
+# Fill in the function body — replace `pass` with the correct return statement.
+
+
+def apply_twice(func, value):
+    pass
+
+
+triple = lambda x: x * 3
+add_ten = lambda x: x + 10

pythonlings/curriculum/exercises/functional/functional7.py

@@ -0,0 +1,12 @@
+# Exercise: Functional 7
+# I AM NOT DONE
+#
+# `make_multiplier(n)` should RETURN a function that multiplies its argument by n.
+# Example: triple = make_multiplier(3); triple(4) → 12
+#
+# Replace `pass` inside `make_multiplier` with a return statement that
+# returns a lambda (or inner function) capturing `n`.
+
+
+def make_multiplier(n):
+    pass