The output The function count_generator has run n times will be printed 1 time.

Explanation: When you decorate count_generator() with @function_logger, the decorator wraps the function. When you call count_generator(), it calls the wrapper function once, which increments the counter to 1 and prints “The function count_generator has run 1 times”, then returns a generator object. The subsequent calls to next(gen) don’t invoke the decorated function again—they operate on the generator object that was already created.

The output The function do_nothing has run n times will be printed 5 times.

Explanation: Each call to do_nothing() in the loop invokes the wrapper function, incrementing the counter. So:

• First call: counter = 1, prints “The function do_nothing has run 1 times”
• Second call: counter = 2, prints “The function do_nothing has run 2 times”
• Third call: counter = 3, prints “The function do_nothing has run 3 times”
• Fourth call: counter = 4, prints “The function do_nothing has run 4 times”
• Fifth call: counter = 5, prints “The function do_nothing has run 5 times”

The key difference is that count_generator is called once and returns a generator object, while do_nothing is called 5 times in the loop.

def fibonacci_generator():
    a, b = 0, 1
    while True:
        reset = yield a
        if reset is not None: # ie. a value was sent, be it 0 or otherwise
            a, b = 0, 1
        else:
            a, b = b, a + b

Explanation: The coroutine uses yield with a value to receive data via send(). When send() is called with a value, the yield statement returns that value to the variable reset. If a value is sent (not None), the Fibonacci sequence is reset to the beginning. Otherwise, the sequence continues to the next Fibonacci number.

Output:

10

Explanation: The typical idea with a decorator is to wrap a function, enhancing its behavior by executing code before and/or after the original function call, but the point is that the inner function of a decorator will call the original function (the func parameter in the above code) at some point. However, in this case, the decorator completely replaces the original gen function with a new function inner that returns a generator expression (x for x in range(5)).

When gen() is called, it actually calls inner(), which returns a generator that yields numbers from 0 to 4. The sum() function then adds these numbers together: 0 + 1 + 2 + 3 + 4 = 10.

Output:

3

Explanation: The inner generator (y for y in range(3)) produces 0, 1, 2. The outer generator (x for x in ...) iterates over these values. The sum() function adds them: 0 + 1 + 2 = 3.

No syntax error. Single-element tuples must have a trailing comma, otherwise it would not be recognized as a tuple. Output:

[(0,), (0,), (0,), (1,)]

Explanation: The generator expression creates tuples containing the product of x and y. It iterates through:

• x=0, y=0: (0*0,) = (0,)
• x=0, y=1: (0*1,) = (0,)
• x=1, y=0: (1*0,) = (0,)
• x=1, y=1: (1*1,) = (1,)

Note: The parentheses around x * y, create a tuple. Without them, it would be a syntax error because the comma would be ambiguous in the comprehension.

Output:

-100

Explanation: Decorators are applied bottom-to-top. The decoration order is:

1. number(n) returns n
2. @dec3 wraps it: a function that returns func(x) + 5, so dec3(5) = 5 + 5 = 10
3. @dec2 wraps it: a function that returns -func(x), so dec2(5) = -(10) = -10
4. @dec1 wraps it: a function that returns func(x) * 10, so dec1(5) = -10 * 10 = -100

The final result is -100.

Output:

('a', '1', True)
('a', '1', False)
('a', '2', True)

Explanation: The nested generator creates tuples by iterating through x, then y, then z. The innermost loop (z) completes first:

• First: x=‘a’, y=‘1’, z=True → (‘a’, ‘1’, True)
• Second: x=‘a’, y=‘1’, z=False → (‘a’, ‘1’, False)
• Third: x=‘a’, y=‘2’, z=True → (‘a’, ‘2’, True)

The order is depth-first with the rightmost loop varying fastest.

Output:

True

Explanation: This demonstrates the shallow copy pitfall. data.copy() creates a shallow copy, meaning it copies the top-level dictionary but not the nested dictionaries. Both data and new_data share the same reference to the nested “lines” dictionary. When you modify new_data["lines"]["hello there"], you’re modifying the shared nested dictionary, so data is also affected. Therefore, data == new_data is True.

To get the opposite output (False), use a deep copy:

import copy
 
new_data = copy.deepcopy(data)
new_data["lines"]["hello there"] = 2
 
print(data == new_data)  # Output: False

A deep copy recursively copies all nested objects, so modifications to new_data don’t affect data.

Output:

{'a': 1, 'b': 3, 'c': 4}

Explanation: Dictionary unpacking (**) is applied left to right. First, d1 is unpacked giving {'a': 1, 'b': 2}. Then, d2 (the original {'b': 3, 'c': 4}) is unpacked. When there are duplicate keys, the rightmost value wins. So 'b' has value 3 (from the second unpacking), not 2. The result is {'a': 1, 'b': 3, 'c': 4}.

def create_memo(func):
    cache = {}
 
    def memoize(x):
        if x not in cache:
            cache[x] = func(x)
        return cache[x]
 
    return memoize

Explanation: The memoization function creates a cache dictionary. When the memoize function is called, it creates a key from the arguments. If the key is in the cache, it returns the cached result. Otherwise, it calls the original function, stores the result in the cache, and returns it. This avoids redundant calculations for the same inputs.

Furthermore, this implementation of a memo is limited to a func takes a single integer argument. If you want to generalize it for functions with multiple arguments, you can use *args and **kwargs to create a more flexible caching mechanism.

Also, notice how we implemented a pattern involving a closure similar to decorators, where create_memo returns a new function memoize that adds memoization behavior to the original function func. So, create_memo can be used as a decorator as well:

@create_memo
def square(x):
    print(f"Computing {x} squared... ", end="")
    return x * x
 
result = square(5)  # This will compute and cache the result
result = square(5)  # This will skip the compute and return the cached result

So, really what was shown earlier was an implementation of a decorator that adds memoization to a function, and used it manually instead of with the @ syntax. This shows the underlying mechanics of how decorators work in Python.

defaultdict from the collections module can be useful for counting occurrences of words without needing to check if the key exists first. It can help to reduce boilerplate code when counting.

The below code creates a defaultdict where the values for missing keys default to 0, but is unnecessarily verbose compared to using defaultdict(int)

from collections import defaultdict
 
word_count = defaultdict(lambda: 0)

defaultdict(int) works as an equivalent to defaultdict(lambda: 0) because invoking int() returns 0, therefore int can act as a callback that returns 0 for initializing values for missing keys.

from collections import defaultdict
 
word_count = defaultdict(int)

Print lines with more than 30 characters

def print_long_lines(filename):
    with open(filename, 'r') as fd:
        for line in fd:
            # Strip punctuation and newline characters from ends
            line = line.strip("\n")
            if len(line) > 30:
                print(line)

Alternatively, using splitlines() to avoid newline characters by default:

def print_long_lines(filename):
    with open(filename, 'r') as fd:
        for line in fd.read().splitlines():
            if len(line) > 30:
                print(line)

Return words that appear more than once

def get_repeated_words(filename):
    word_count = {}
 
    with open(filename, 'r') as fd:
        for line in fd:
            words = line.split()
            for word in words:
                # Strip punctuation from ends
                clean_word = word.strip(PUNCTUATION)
 
                # Skip empty strings after stripping
                if not clean_word:
                    continue
 
                if clean_word in word_count:
                    word_count[clean_word] += 1
                else:
                    word_count[clean_word] = 1
 
    return [word for word, count in word_count.items() if count > 1]

Alternative using defaultdict:

from collections import defaultdict
 
def get_repeated_words(filename):
    word_count = defaultdict(int)
 
    with open(filename, 'r') as fd:
        for line in fd:
            words = line.split()
            for word in words:
                # Strip punctuation from ends
                clean_word = word.strip(PUNCTUATION)
 
                # Skip empty strings after stripping
                if not clean_word:
                    continue
 
                word_count[clean_word] += 1
 
    return [word for word, count in word_count.items() if count > 1]

Count lines starting with a vowel

def count_vowel_start_lines(filename):
    vowels = 'aeiou'
    count = 0
 
    with open(filename, 'r') as fd:
        for line in fd:
            if line and line[0].lower() in vowels:
                count += 1
    return count

Count unique words (case-insensitive, strip punctuation from ends)

def count_unique_words(filename):
    unique_words = set()
 
    with open(filename, 'r') as fd:
        for line in fd:
            words = line.lower().split()
            for word in words:
                # Strip punctuation from ends
                clean_word = word.strip(PUNCTUATION)
                if clean_word:
                    unique_words.add(clean_word)
 
    return len(unique_words)

Return unique count and 5 most common words (using a dictionary)

def count_unique_words_with_top(filename):
    word_count = {}
 
    with open(filename, 'r') as fd:
        for line in fd:
            words = line.lower().split()
            for word in words:
                clean_word = word.strip(PUNCTUATION)
 
                # Skip empty strings after stripping
                if not clean_word:
                    continue
 
                if clean_word in word_count:
                    word_count[clean_word] += 1
                else:
                    word_count[clean_word] = 1
 
    unique_count = len(word_count)
    sorted_by_decreasing_word_count = sorted(word_count.items(), key=lambda x: x[1], reverse=True)
 
    return unique_count, sorted_by_decreasing_word_count[:5]

Alternative using defaultdict:

from collections import defaultdict
 
def count_unique_words_with_top(filename):
    word_count = defaultdict(int)
 
    with open(filename, 'r') as fd:
        for line in fd:
            words = line.lower().split()
            for word in words:
                clean_word = word.strip(PUNCTUATION)
                if clean_word:
                    word_count[clean_word] += 1
 
    unique_count = len(word_count)
    sorted_by_decreasing_word_count = sorted(word_count.items(), key=lambda x: x[1], reverse=True)
 
    return unique_count, sorted_by_decreasing_word_count[:5]

Generator function for sentences

def sentence_generator(filename):
    with open(filename, 'r') as fd:
        for line in fd.read().splitlines():
            if not line:
                continue
            if line.endswith(('.', '!', '?')):
                yield line