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 memoized(x):
        if x not in cache:
            cache[x] = func(x)
        return cache[x]
 
    return memoized

Explanation: The memoization function creates a cache dictionary. When the memoized 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.

Print lines with more than 30 characters

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)
                if clean_word:
                    word_count[clean_word] = word_count.get(clean_word, 0) + 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)
                if clean_word:
                    word_count[clean_word] = word_count.get(clean_word, 0) + 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):
    # this creates a defaultdict where missing keys default to 0
    # but is unnecessarily verbose compared to using defaultdict(int)
    # 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 missing keys.
    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:
        text = fd.read()
 
    sentence = ""
    for char in text:
        sentence += char
        if char in '.!?':
            yield sentence.strip() # strip leading/trailing whitespace
            sentence = ""