pythonlings 0.3.0__py3-none-any.whl

pythonlings/curriculum/exercises/recursion/recursion6.py

@@ -0,0 +1,13 @@
+# Exercise: Recursion 6
+# ---------------------
+# I AM NOT DONE
+#
+# Complete `reverse_string(s)` so it returns the string `s` reversed
+# using recursion.  Base case: a string of length 0 or 1 is already
+# reversed.  Recursive case: reverse the tail, then append the first
+# character.
+
+def reverse_string(s):
+    if len(s) <= 1:
+        return s
+    return ???

pythonlings/curriculum/exercises/recursion/recursion7.py

@@ -0,0 +1,20 @@
+# Exercise: Recursion 7
+# ---------------------
+# I AM NOT DONE
+#
+# Complete `deep_sum(nested)` so it returns the sum of all numbers in a
+# possibly-nested list.  Each element is either an int/float or another
+# list.  Base case: empty list returns 0.  Recursive case: if the first
+# element is a list, deep_sum it; otherwise treat it as a plain number.
+# Add that to deep_sum of the rest.
+#
+# Example: deep_sum([1, [2, 3], [4, [5]]]) == 15
+
+def deep_sum(nested):
+    if not nested:
+        return 0
+    first = nested[0]
+    rest = nested[1:]
+    if isinstance(first, list):
+        return deep_sum(first) + ???
+    return first + deep_sum(rest)

pythonlings/curriculum/exercises/recursion/recursion8.py

@@ -0,0 +1,27 @@
+# Exercise: Recursion 8
+# ---------------------
+# I AM NOT DONE
+#
+# A tree is represented as a dict with keys "value" (int) and
+# "children" (list of trees, possibly empty).
+#
+# Complete two functions:
+#
+#   tree_depth(tree) — returns the depth of the tree.  A tree with no
+#     children has depth 1.  Otherwise depth is 1 + max depth of children.
+#
+#   tree_search(tree, target) — returns True if `target` appears as a
+#     "value" anywhere in the tree, False otherwise.
+#
+# Both must be recursive.
+
+def tree_depth(tree):
+    if not tree["children"]:
+        return 1
+    return ???
+
+
+def tree_search(tree, target):
+    if tree["value"] == target:
+        return True
+    return ???

pythonlings/curriculum/exercises/regex/regex1.py

@@ -0,0 +1,16 @@
+# Exercise: Regex 1
+# I AM NOT DONE
+#
+# Use re.match to check whether `text` starts with the word "hello".
+# Store the result (a match object or None) in `result`.
+#
+# re.match(pattern, string) returns a match object if the beginning of
+# `string` matches `pattern`, otherwise None.
+#
+# Fix the pattern so that `result` is not None for the given `text`.
+
+import re
+
+text = "hello world"
+pattern = "???"
+result = re.match(pattern, text)

pythonlings/curriculum/exercises/regex/regex10.py

@@ -0,0 +1,31 @@
+# Exercise: Regex 10
+# I AM NOT DONE
+#
+# Parse a structured log line and extract three fields:
+#   level    — the log level word (e.g. "ERROR", "INFO", "WARNING")
+#   logger   — the logger name (word characters only, e.g. "db.engine")
+#   message  — everything after the colon+space at the end
+#
+# Log line format:
+#   [LEVEL] logger_name: message text here
+#
+# Example:
+#   "[ERROR] db.engine: connection refused"
+#   → level="ERROR", logger="db.engine", message="connection refused"
+#
+# Use re.search with named capturing groups (?P<name>...).
+# Fix the pattern (replace ???).
+#
+# Hints:
+#   \[  and  \]   match literal square brackets
+#   [\w.]+        matches word chars and dots (for dotted logger names)
+#   .+            matches the rest of the line (message)
+
+import re
+
+log_line = "[ERROR] db.engine: connection refused"
+pattern = "???"
+match = re.search(pattern, log_line)
+level = match.group("level")
+logger = match.group("logger")
+message = match.group("message")

pythonlings/curriculum/exercises/regex/regex2.py

@@ -0,0 +1,16 @@
+# Exercise: Regex 2
+# I AM NOT DONE
+#
+# Use re.search to find the word "python" anywhere inside `text`.
+# Store the result (a match object or None) in `result`.
+#
+# Unlike re.match, re.search scans through the whole string looking for
+# the first location where the pattern matches.
+#
+# Fix the pattern so that `result` is not None for the given `text`.
+
+import re
+
+text = "I love python programming"
+pattern = "???"
+result = re.search(pattern, text)

pythonlings/curriculum/exercises/regex/regex3.py

@@ -0,0 +1,16 @@
+# Exercise: Regex 3
+# I AM NOT DONE
+#
+# Use re.findall to collect every run of digits in `text` as a list
+# of strings. Store the result in `numbers`.
+#
+# re.findall(pattern, string) returns a list of all non-overlapping
+# matches of `pattern` in `string`.
+#
+# The pattern `\d+` matches one or more digit characters.
+# Fix the pattern (replace ???) so that `numbers` holds all digit runs.
+
+import re
+
+text = "order 12 has 3 items and 450 points"
+numbers = re.findall("???", text)

pythonlings/curriculum/exercises/regex/regex4.py

@@ -0,0 +1,19 @@
+# Exercise: Regex 4
+# I AM NOT DONE
+#
+# Use re.findall with a character-class pattern to collect every
+# lowercase ASCII word (only letters a-z) from `text`.
+# Store the result in `words`.
+#
+# Character classes:
+#   [a-z]   matches any single lowercase letter
+#   [a-z]+  matches a run of one or more lowercase letters
+#
+# Note: `\w` also matches digits and underscores, so use [a-z]+ here.
+# Fix the pattern (replace ???) so that `words` contains only
+# lowercase letter runs, ignoring digits and punctuation.
+
+import re
+
+text = "Hello world 123 foo_bar baz!"
+words = re.findall("???", text)

pythonlings/curriculum/exercises/regex/regex5.py

@@ -0,0 +1,19 @@
+# Exercise: Regex 5
+# I AM NOT DONE
+#
+# Use re.findall to find all tokens that look like version numbers:
+# one or more digits, a literal dot, one or more digits
+# (e.g. "3.10", "1.0", "2.7").
+# Store the result in `versions`.
+#
+# Quantifier reminder:
+#   +     one or more of the preceding element
+#   \d    any digit  (same as [0-9])
+#   \.    a literal dot (dot without backslash means "any character")
+#
+# Fix the pattern (replace ???) to capture version-like tokens.
+
+import re
+
+text = "requires python 3.10 or 2.7, not 1.x or 42"
+versions = re.findall("???", text)

pythonlings/curriculum/exercises/regex/regex6.py

@@ -0,0 +1,23 @@
+# Exercise: Regex 6
+# I AM NOT DONE
+#
+# Use re.fullmatch (or a pattern with ^ and $) to validate that
+# `code` is exactly five uppercase letters followed by exactly three
+# digits — nothing more, nothing less.
+# Store the boolean result in `is_valid`.
+#
+# Anchors:
+#   ^   start of string
+#   $   end of string
+#   {n} exactly n repetitions of the preceding element
+#   [A-Z] any uppercase letter
+#
+# Fix the pattern (replace ???).
+# Example valid code: "ABCDE123"
+# Example invalid: "ABCDE12" (too few digits), "abcde123" (lowercase)
+
+import re
+
+code = "ABCDE123"
+pattern = "???"
+is_valid = bool(re.fullmatch(pattern, code))

pythonlings/curriculum/exercises/regex/regex7.py

@@ -0,0 +1,24 @@
+# Exercise: Regex 7
+# I AM NOT DONE
+#
+# Use re.search with a capturing group to extract the area code from
+# a US phone number of the form "(NXX) NXX-XXXX".
+# Store the three-digit area code string in `area_code`.
+#
+# Capturing groups:
+#   (...)       captures whatever the sub-pattern matches
+#   match.group(1) returns the text captured by the first group
+#
+# The phone number format: (NXX) NXX-XXXX
+#   \(   literal open parenthesis
+#   \d{3} three digits  ← this is the area code to capture
+#   \)   literal close parenthesis
+#
+# Fix the pattern (replace ???) so that group(1) gives the area code.
+
+import re
+
+phone = "(415) 555-2671"
+pattern = "???"
+match = re.search(pattern, phone)
+area_code = match.group(1)

pythonlings/curriculum/exercises/regex/regex8.py

@@ -0,0 +1,19 @@
+# Exercise: Regex 8
+# I AM NOT DONE
+#
+# Use re.sub to censor every occurrence of a bad word in `text` by
+# replacing it with "***". The bad words are: "spam" and "junk".
+# Store the cleaned string in `clean`.
+#
+# re.sub(pattern, replacement, string) returns a new string with all
+# matches replaced by `replacement`.
+#
+# Hint: the pipe character | means "or" in a regex:  spam|junk
+#
+# Fix the pattern (replace ???).
+
+import re
+
+text = "This email is full of spam and junk, total spam!"
+pattern = "???"
+clean = re.sub(pattern, "***", text)

pythonlings/curriculum/exercises/regex/regex9.py

@@ -0,0 +1,22 @@
+# Exercise: Regex 9
+# I AM NOT DONE
+#
+# Use re.search with named capturing groups to parse a date string of
+# the form "YYYY-MM-DD" and extract its parts.
+# Store the results in `year`, `month`, and `day` (all strings).
+#
+# Named groups:
+#   (?P<name>...)   captures text and names it `name`
+#   match.group("name") retrieves the captured text by name
+#
+# Fix the pattern (replace ???) so the three named groups
+# "year", "month", and "day" each capture the appropriate part.
+
+import re
+
+date_str = "2024-07-15"
+pattern = "???"
+match = re.search(pattern, date_str)
+year = match.group("year")
+month = match.group("month")
+day = match.group("day")

pythonlings/curriculum/exercises/sets/sets1.py

@@ -0,0 +1,6 @@
+# Exercise: Sets 1
+# I AM NOT DONE
+#
+# Create a set called `primes` containing the numbers 2, 3, 5, and 7.
+
+primes = ???

pythonlings/curriculum/exercises/sets/sets10.py

@@ -0,0 +1,21 @@
+# Exercise: Sets 10
+# I AM NOT DONE
+#
+# Compare two collections and extract meaningful subsets.
+#
+# You have two lists of students who attended each day of a workshop.
+# Compute:
+#   attended_both  — a set of students who came on BOTH days
+#   attended_any   — a set of students who came on AT LEAST ONE day
+#   only_day1      — a set of students who came on day 1 but NOT day 2
+#   only_day2      — a set of students who came on day 2 but NOT day 1
+#
+# Use set operations (|, &, -) on sets converted from the lists.
+
+day1 = ["alice", "bob", "carol", "dave"]
+day2 = ["bob", "carol", "eve", "frank"]
+
+attended_both = ???
+attended_any = ???
+only_day1 = ???
+only_day2 = ???

pythonlings/curriculum/exercises/sets/sets2.py

@@ -0,0 +1,12 @@
+# Exercise: Sets 2
+# I AM NOT DONE
+#
+# Start with the set `colors` below.
+# 1. Add the string "purple" to it using `.add()`.
+# 2. Remove "orange" from it using `.discard()`.
+#
+# After both operations, `colors` should equal {"red", "blue", "purple"}.
+
+colors = {"red", "blue", "orange"}
+# your code here
+???

pythonlings/curriculum/exercises/sets/sets3.py

@@ -0,0 +1,15 @@
+# Exercise: Sets 3
+# I AM NOT DONE
+#
+# Use the `in` operator to check membership in a set.
+#
+# Given the set `fruits`, set:
+#   has_apple  = True if "apple"  is in fruits, False otherwise
+#   has_grape  = True if "grape"  is in fruits, False otherwise
+#
+# Do NOT use literals True or False directly — use the `in` operator.
+
+fruits = {"apple", "banana", "cherry"}
+
+has_apple = "apple" ??? fruits
+has_grape = "grape" ??? fruits

pythonlings/curriculum/exercises/sets/sets4.py

@@ -0,0 +1,14 @@
+# Exercise: Sets 4
+# I AM NOT DONE
+#
+# Compute the union of two sets — every element that appears in either set.
+#
+# Given `a` and `b`, store their union in `combined`.
+# Use the `|` operator or the `.union()` method.
+#
+# Expected: combined == {1, 2, 3, 4, 5, 6}
+
+a = {1, 2, 3, 4}
+b = {3, 4, 5, 6}
+
+combined = ???

pythonlings/curriculum/exercises/sets/sets5.py

@@ -0,0 +1,14 @@
+# Exercise: Sets 5
+# I AM NOT DONE
+#
+# Compute the intersection of two sets — only elements present in BOTH sets.
+#
+# Given `a` and `b`, store their intersection in `shared`.
+# Use the `&` operator or the `.intersection()` method.
+#
+# Expected: shared == {3, 4}
+
+a = {1, 2, 3, 4}
+b = {3, 4, 5, 6}
+
+shared = ???

pythonlings/curriculum/exercises/sets/sets6.py

@@ -0,0 +1,14 @@
+# Exercise: Sets 6
+# I AM NOT DONE
+#
+# Compute the difference of two sets — elements in `a` that are NOT in `b`.
+#
+# Given `a` and `b`, store `a` minus `b` in `only_in_a`.
+# Use the `-` operator or the `.difference()` method.
+#
+# Expected: only_in_a == {1, 2}
+
+a = {1, 2, 3, 4}
+b = {3, 4, 5, 6}
+
+only_in_a = ???

pythonlings/curriculum/exercises/sets/sets7.py

@@ -0,0 +1,16 @@
+# Exercise: Sets 7
+# I AM NOT DONE
+#
+# Remove duplicates from a list by converting it to a set.
+#
+# Given `numbers` (a list with repeated values), create `unique` — a set
+# containing exactly the distinct values from `numbers`.
+#
+# Then create `unique_count` — the number of unique values (an int).
+#
+# Expected: unique == {1, 2, 3, 4, 5} and unique_count == 5
+
+numbers = [1, 2, 3, 2, 4, 1, 5, 3, 2, 4]
+
+unique = ???
+unique_count = ???

pythonlings/curriculum/exercises/sets/sets8.py

@@ -0,0 +1,16 @@
+# Exercise: Sets 8
+# I AM NOT DONE
+#
+# Test subset and superset relationships between sets.
+#
+# Given `small` and `big` below, compute:
+#   is_subset   — True if `small` is a subset of `big`   (use <= or .issubset())
+#   is_superset — True if `big` is a superset of `small` (use >= or .issuperset())
+#
+# Expected: both is_subset and is_superset should be True.
+
+small = {2, 4}
+big = {1, 2, 3, 4, 5}
+
+is_subset = ???
+is_superset = ???

pythonlings/curriculum/exercises/sets/sets9.py

@@ -0,0 +1,15 @@
+# Exercise: Sets 9
+# I AM NOT DONE
+#
+# Use a set comprehension to build a set of squares of even numbers.
+#
+# Given `numbers`, create `even_squares` — a set containing the square of
+# every even number in `numbers`.
+#
+# Use a set comprehension: {expr for item in iterable if condition}
+#
+# Expected: even_squares == {4, 16, 36}
+
+numbers = [1, 2, 3, 4, 5, 6, 7]
+
+even_squares = ???

pythonlings/curriculum/exercises/strings/strings1.py

@@ -0,0 +1,6 @@
+# Exercise: Strings 1
+# I AM NOT DONE
+#
+# Assign the string "hello" to the variable `greeting`.
+
+greeting = ???

pythonlings/curriculum/exercises/strings/strings10.py

@@ -0,0 +1,11 @@
+# Exercise: Strings 10
+# I AM NOT DONE
+#
+# Build a formatted report line from the given data. The expected result is:
+#   "Item: widget | Qty: 42 | Price: $3.99"
+# Use an f-string. The price must be formatted to exactly 2 decimal places.
+
+item = "widget"
+qty = 42
+price = 3.99
+report = ???

pythonlings/curriculum/exercises/strings/strings2.py

@@ -0,0 +1,9 @@
+# Exercise: Strings 2
+# I AM NOT DONE
+#
+# Use the `+` operator to concatenate `first` and `last` (with a space in
+# between) and assign the result to `full_name`.
+
+first = "Ada"
+last = "Lovelace"
+full_name = ???

pythonlings/curriculum/exercises/strings/strings3.py

@@ -0,0 +1,9 @@
+# Exercise: Strings 3
+# I AM NOT DONE
+#
+# Using indexing on `word`, assign its first character to `first_char`
+# and its last character to `last_char`.
+
+word = "python"
+first_char = ???
+last_char = ???

pythonlings/curriculum/exercises/strings/strings4.py

@@ -0,0 +1,8 @@
+# Exercise: Strings 4
+# I AM NOT DONE
+#
+# Using a slice on `sentence`, extract the word "quick" (characters at
+# indices 4 through 8 inclusive) and assign it to `word`.
+
+sentence = "the quick brown fox"
+word = ???

pythonlings/curriculum/exercises/strings/strings5.py

@@ -0,0 +1,10 @@
+# Exercise: Strings 5
+# I AM NOT DONE
+#
+# Assign the number of characters in `text` to `length`, its all-uppercase
+# form to `upper`, and its all-lowercase form to `lower`.
+
+text = "Hello, World!"
+length = ???
+upper = ???
+lower = ???

pythonlings/curriculum/exercises/strings/strings6.py

@@ -0,0 +1,10 @@
+# Exercise: Strings 6
+# I AM NOT DONE
+#
+# Use .strip() to remove leading and trailing whitespace from `raw` and
+# assign the result to `clean`. Then use .replace() to swap every "cat"
+# in `clean` with "dog" and assign the result to `replaced`.
+
+raw = "  I love cats and cats  "
+clean = ???
+replaced = ???

pythonlings/curriculum/exercises/strings/strings7.py

@@ -0,0 +1,10 @@
+# Exercise: Strings 7
+# I AM NOT DONE
+#
+# Use .split() to break `csv_line` on commas and assign the resulting list
+# to `items`. Then use ", ".join() to reassemble `items` back into a single
+# string and assign it to `rejoined`.
+
+csv_line = "apple,banana,cherry"
+items = ???
+rejoined = ???

pythonlings/curriculum/exercises/strings/strings8.py

@@ -0,0 +1,9 @@
+# Exercise: Strings 8
+# I AM NOT DONE
+#
+# Use an f-string to build a greeting of the form "Hello, <name>! You are
+# <age> years old." and assign it to `message`. Do not use concatenation.
+
+name = "Grace"
+age = 30
+message = ???

pythonlings/curriculum/exercises/strings/strings9.py

@@ -0,0 +1,10 @@
+# Exercise: Strings 9
+# I AM NOT DONE
+#
+# Use the `in` operator to check whether "fox" appears in `sentence` and
+# assign the boolean result to `has_fox`. Then use .find() to find the
+# index where "fox" starts and assign it to `fox_index`.
+
+sentence = "the quick brown fox jumps"
+has_fox = ???
+fox_index = ???

pythonlings/curriculum/exercises/testing/testing1.py

@@ -0,0 +1,16 @@
+# Exercise: Testing 1
+# I AM NOT DONE
+#
+# The simplest test in Python is a plain `assert` statement.
+# If the expression is True, nothing happens; if False, an AssertionError
+# is raised and the test fails.
+#
+# Replace ??? so that the assertion holds:
+#   result should equal 4 after calling double(2).
+
+def double(x):
+    return x * 2
+
+
+result = double(2)
+assert result == ???

pythonlings/curriculum/exercises/testing/testing10.py

@@ -0,0 +1,21 @@
+# Exercise: Testing 10
+# I AM NOT DONE
+#
+# Robust tests include *edge cases*: empty input, zero, negatives, and
+# boundary values — the inputs most likely to expose bugs.
+#
+# Complete `test_sum_list` to cover ALL of the following edge cases for
+# `sum_list(numbers)`:
+#   sum_list([])          == 0         (empty list)
+#   sum_list([0])         == 0         (single zero)
+#   sum_list([-1, -2])    == -3        (all negatives)
+#   sum_list([1, -1])     == 0         (cancellation)
+#   sum_list([1, 2, 3])   == 6         (normal case)
+
+def sum_list(numbers):
+    return sum(numbers)
+
+
+def test_sum_list():
+    # write five assertions covering the edge cases above
+    pass

pythonlings/curriculum/exercises/testing/testing11.py

@@ -0,0 +1,27 @@
+# Exercise: Testing 11
+# I AM NOT DONE
+#
+# Testing a class means: construct an instance, call its methods, and
+# assert the resulting state is correct.
+#
+# Complete `test_counter` to verify the Counter class:
+#   1. A new Counter starts at 0.
+#   2. After calling increment() once, value is 1.
+#   3. After calling increment() again, value is 2.
+#   4. After calling reset(), value is back to 0.
+
+class Counter:
+    def __init__(self):
+        self.value = 0
+
+    def increment(self):
+        self.value += 1
+
+    def reset(self):
+        self.value = 0
+
+
+def test_counter():
+    # 1. create a Counter instance
+    # 2-4. assert state after each method call
+    pass

pythonlings/curriculum/exercises/testing/testing12.py

@@ -0,0 +1,51 @@
+# Exercise: Testing 12
+# I AM NOT DONE
+#
+# A test suite is a collection of test functions that together give
+# confidence in a whole module. Write a *separate* test function for each
+# concern rather than cramming everything into one.
+#
+# Below is a small "string_utils" module. Write four test functions:
+#
+#   test_palindrome()    — verify is_palindrome for at least 3 inputs
+#                          (one true, one false, one edge case like "")
+#   test_word_count()    — verify word_count for at least 3 inputs
+#                          (normal sentence, single word, empty string)
+#   test_title_case()    — verify to_title_case for at least 2 inputs
+#   test_truncate()      — verify truncate for at least 3 inputs
+#                          (short string unchanged, long string truncated,
+#                           boundary length exactly)
+
+def is_palindrome(s):
+    s = s.lower().replace(" ", "")
+    return s == s[::-1]
+
+
+def word_count(s):
+    if not s.strip():
+        return 0
+    return len(s.split())
+
+
+def to_title_case(s):
+    return s.title()
+
+
+def truncate(s, max_len):
+    return s if len(s) <= max_len else s[:max_len] + "..."
+
+
+def test_palindrome():
+    pass
+
+
+def test_word_count():
+    pass
+
+
+def test_title_case():
+    pass
+
+
+def test_truncate():
+    pass