CCNA Functions, Tuples, Dictionaries and Exceptions Questions

The finally clause executes regardless of whether an exception occurred or not.

keys() returns a view object of the dictionary's keys and is a genuine built-in dict method. It satisfies the question's requirement for a valid dictionary method, distinguishing it from list-only operations such as append or index.

A parameter prefixed with an asterisk collects any extra positional arguments into a tuple. Here restock_dates becomes ('2024-01-05', '2024-02-11'), so len(restock_dates) returns 2. Because it is a tuple, it supports len, indexing, and iteration, which is exactly how variadic functions inspect the surplus arguments they received.

Validating every element with a numeric type check before summing prevents silent wrong results from strings or None. Raising TypeError signals invalid input explicitly, satisfying the requirement to handle non-numeric values rather than returning an incorrect average.

Default parameters apply when an argument is omitted at call time. Calling `greet('Alice')` supplies only `name`, so Python binds `greeting` to its default value `'Hello'`, printing `Hello Alice`. The single positional argument satisfies `name`, leaving the optional parameter untouched.

The comprehension iterates x over range(3), giving 0, 1 and 2, and maps each to its square. The resulting dictionary pairs 0 with 0, 1 with 1 and 2 with 4, producing exactly {0:0, 1:1, 2:4}.

values returns a view of dictionary values.

Dictionaries in Python are mutable objects. When passed to a function, the parameter config refers to the same dictionary object as my_config. The statement config[key] = value mutates that shared object, so the caller sees the change. No copy is made unless explicitly requested. Thus my_config now maps 'debug' to True, and result also refers to the same updated dictionary.

This function checks if the dictionary is empty and returns None. Otherwise, it uses max with the key argument set to scores.get, which retrieves the value for each key and returns the key with the highest value. This correctly identifies the top student.

Positional arguments 1 and 2 are collected into the args tuple, while keyword arguments a=3 and b=4 are collected into the kwargs dictionary. Printing both objects therefore yields the tuple (1, 2) followed by the dictionary {'a': 3, 'b': 4}.

Correct: Python supports both positional and keyword arguments.

except Exception: catches only subclasses of Exception, so FileNotFoundError and PermissionError still trigger cleanup, while KeyboardInterrupt and SystemExit (which derive from BaseException, not Exception) propagate and allow a clean exit. This precisely satisfies the requirement to exclude system-exiting exceptions.

Catching FileNotFoundError and PermissionError in separate except blocks lets the script handle each I/O failure precisely while unhandled exceptions, such as ValueError, propagate naturally. This satisfies the stem's requirement to catch only I/O-related exceptions, since a single broad handler would incorrectly intercept unrelated errors.

copy.deepcopy() recursively duplicates every nested dictionary and list, producing a fully independent object graph. A shallow copy or dict() only copies the top level, leaving nested references shared, so mutations would still propagate to the original argument.

When a function is called with positional arguments, they are matched to parameters in the order they are defined. Here, the first argument 5 binds to length and the second argument 3 binds to width. The multiplication 5 * 3 yields 15. No keyword arguments are used, so there is no ambiguity. This is the standard positional argument passing mechanism in Python.

The inner `except ZeroDivisionError` catches the division by zero and raises a new `ValueError('Invalid division')`. The outer `try` block's `except ValueError as e` handler catches this propagated exception and prints its message, so the output is `Invalid division`.

Assigning to an index of a tuple raises TypeError because tuples are immutable: their elements cannot be reassigned after creation. The statement `t[0] = 3` attempts item assignment on a tuple, which Python rejects outright, satisfying the stem's requirement for a TypeError rather than a silent success or a different exception.

This is correct because the default argument `basket=[]` is evaluated once when the function is defined, creating a single list object. Each call that omits the basket argument uses that same list and appends the item, so all three items accumulate. This is a classic Python pitfall with mutable default arguments.

Tuples are immutable, so item assignment such as t[0] = 0 is unsupported. Python raises a TypeError at runtime rather than silently ignoring the change, which is the defined behaviour for attempting to modify tuple elements.

This is correct because it checks the divisor before performing division and explicitly raises ValueError with a custom message when b is zero. This prevents a ZeroDivisionError from occurring and gives the caller a more meaningful exception. The return statement executes only when b is non-zero, ensuring safe division.

The `get` method returns None if the key is not found, without raising an exception. It is a safe way to access a key that may not exist. In this case, 'timeout' is not present, so it returns None. This operation is valid and will not raise an error.

The dict.get method returns the value mapped to the key when the key exists, and it returns the second argument as a default when the key is absent, so missing keys never raise an error. In this scenario it yields 'Osaka' for the current record and 'UNKNOWN' for any record lacking a destination, letting the program continue processing shipments.

The dictionary comprehension iterates over each element in `names`, binding `name` to the string and computing `len(name)` as its value, producing `{'Alice': 5, 'Bob': 3, 'Charlie': 7}`. This satisfies the requirement to map every name to its length in a single expression, unlike `map` or `zip` alternatives.

When data[key] is evaluated and the key 'b' is not found, a KeyError is raised. The except KeyError block catches this specific exception and executes its body, which returns None. The function then exits normally. This demonstrates how exception handling can provide a fallback value instead of crashing. The caller receives None as the result.

Returning comma-separated values from a function packs them into a single tuple, so `min_max` yields a two-element tuple containing the minimum and maximum. This satisfies the stem's requirement to identify the return type: the parentheses are optional, but the comma operator always constructs a tuple.

The `+=` operator on a tuple does not modify the original tuple in place because tuples are immutable. Instead, it creates a new tuple by concatenating the existing tuple with the new element, then rebinds the variable `result` to this new tuple. This allows the function to accumulate even numbers correctly, as each iteration produces a new tuple.

The expression lst + [item] creates a brand-new list object and rebinds the local name lst to it. The caller's original list object is never mutated, so after the function returns the caller still sees the unchanged list. The new list is returned for the caller to use if desired, which satisfies the requirement of appending without affecting the caller's list.

Correct. The trailing comma is required to create a single-element tuple.

Tuples are immutable, so any assignment to an index raises a TypeError at runtime. The interpreter blocks the modification rather than silently ignoring it, which satisfies the stem's scenario of attempting to change a tuple element.

Accessing a missing dictionary key raises KeyError, satisfying the stem's requirement for the exception triggered by absent keys. Python's dict lookup invokes `__getitem__`, which raises KeyError rather than returning a default, unlike `get()`. This distinguishes it from IndexError, used by sequences such as lists and tuples.

Default parameter values are used only when the caller does not supply that argument. The first call omits level, so the default 'INFO' is bound; the second call passes level explicitly by keyword, which overrides the default with 'WARN'. Both calls succeed and produce the intended log entries for the developer.

Keyword arguments bind by parameter name rather than position, so the caller may supply them in any sequence and Python still maps each value to the matching parameter. This satisfies the stem's requirement that ordering is irrelevant, unlike positional arguments, which must follow the definition's sequence exactly.

Lists support integer indexing, so data[key] with an integer key retrieves the element at that position. The try block succeeds, and the function returns that element. The except KeyError clause is not triggered because no KeyError occurs. Thus, the function works correctly for lists with integer indices, returning the desired element.

The get method returns the current count if the key exists and 0 otherwise, so the expression always produces a valid integer to increment. Assigning the result back to counts[word] creates the key on first encounter and updates it thereafter. This one-line idiom avoids a KeyError and correctly accumulates frequencies for every distinct word in the list.

Dictionary keys require hashability, and a tuple is hashable when every contained element is hashable. Immutability alone is insufficient; a tuple holding a list cannot serve as a key, so the condition on all elements is the precise constraint.

The *args syntax collects all positional arguments into a tuple named args, which can then be passed to the built-in sum function. This allows the function to accept zero or more arguments. It is the standard way to define a variadic function in Python.

The raise statement instantiates ValueError with the custom message string passed as its argument, immediately propagating the exception. This satisfies the requirement to raise ValueError with a custom message when a negative number is supplied, using correct Python exception-raising syntax.

The trailing comma is what makes this a tuple rather than an integer in parentheses. Python's grammar requires that comma to disambiguate a single-element tuple from a grouped expression, so `(5,)` satisfies the stem's constraint of holding exactly one integer, 5. Without it, `t = (5)` binds an int.

Correct.

A tuple is immutable, so once it is created, its elements cannot be changed. This makes it ideal for storing a fixed set of error codes that should not be modified during program execution. The programmer can be confident that the collection remains constant, preventing accidental changes. Tuples also support indexing and iteration, making them convenient for lookups.

Catching the specific exception type handles only the anticipated ineligibility case and binds the exception instance to err for logging. Any other exception, such as ZeroDivisionError, does not match this clause and therefore propagates to the outer handler. This selective approach gives precise control over which failures are swallowed and which are escalated.

Rebinding the name 'list' shadows the built-in, causing the TypeError. Renaming the local variable removes the shadowing while preserving the function's signature and return value, so external behaviour is unchanged. This is the standard fix for name shadowing in Python.

The inner except catches ValueError, then raises TypeError, which propagates uncaught by f(). The outer handler matching TypeError prints its message, so 'error2' is emitted; the ValueError clause never executes because no ValueError reaches the outer try.

The inner raise TypeError is not caught by the ValueError handler, so it propagates to the outer except TypeError, printing B. The finally block always executes, printing C afterwards. The ValueError branch never runs, so A is never printed.

Dictionaries are mutable and passed by object reference, so adding a key inside the function mutates the caller's original. Calling data.copy() creates a shallow copy bound to the local name, so subsequent key additions affect only the copy, leaving the caller's dictionary unchanged.

Accessing a missing key with subscript notation raises KeyError, because dictionaries do not return a default for absent keys. The stem's `user` dictionary holds only `'id'` and `'name'`, so `user['email']` fails immediately at runtime rather than returning `None`.

A `finally` block's `return` overrides any `return` in the `try` block, so the value 2 replaces the pending 1 before the function exits. Python discards the earlier return value once `finally` executes its own `return`, making 2 the printed output.

The function has a default parameter unit with default value "C", but the caller explicitly passes unit="F" as a keyword argument. This overrides the default, so the returned string uses "F" as the unit. The value 22 is passed positionally to the value parameter. Therefore, the f-string evaluates to "T1: 22F".

Python evaluates except clauses in written order, and a specific handler takes precedence over a bare except. Since ValueError matches the named clause first, that handler runs; the bare except only catches exceptions no earlier clause matched.

int('12.5') raises ValueError because the string contains a decimal point that int cannot parse. The except ValueError clause matches that exception, so its body executes and adds zero to the running total. Because the exception is handled, the program does not terminate; control resumes after the try-except statement, which is the intended graceful-degradation behaviour.

A dictionary maps each string key directly to its associated list, giving O(1) average lookup by key. This satisfies the stem's requirement for string-keyed configuration where each key holds multiple allowed values, since lists preserve the ordered collection of values per key without needing separate parallel structures.

This uses a dictionary literal with integer keys and string values. The syntax {key: value, ...} is the standard way to create a dictionary. It correctly maps employee IDs (101 and 102) to department names ("HR" and "IT"). This is valid and creates the desired dictionary.

Using *nums in the parameter list collects all positional arguments into a tuple named nums, which works even when no arguments are passed (nums becomes an empty tuple). The built-in sum() then returns 0 for an empty tuple, satisfying the zero-argument requirement.

Python lambda syntax places parameters before the colon and the single return expression after it, with no return keyword. Writing lambda a, b: a + b correctly declares two parameters and returns their sum, matching the two-argument addition requirement exactly.

The loop rebinds the same variable each iteration, and the final assignment leaves it holding 2. Printing after the loop completes therefore emits 2 2 2, because all three print calls reference the variable's last value rather than capturing each iteration's value separately.

The function uses *args to collect all positional arguments into a tuple. When called with 1, 2, 3, args becomes (1, 2, 3). The built-in sum function then adds these numbers, resulting in 6. This is the correct output.

Standard dictionary literal.

The default list argument is evaluated once at function definition, so the same mutable list object persists across calls. The first call appends 1, returning [1]; the second appends to that same list, returning [1, 1]. This is Python's classic mutable default argument pitfall.

Tuples are immutable sequences, so item assignment is unsupported. Attempting `months[1] = "Februar"` invokes the tuple's missing `__setitem__` behaviour, raising `TypeError: 'tuple' object does not support item assignment`. This satisfies the stem's constraint that the element change cannot succeed, unlike a list, which permits such mutation.

This implementation iterates through the keys, checks if each key exists in the current dictionary, and raises MissingKeyError with the missing key if not. It then descends into the nested dictionary. This correctly handles missing keys at any level and returns the final value. It uses the 'in' operator to check membership, which is efficient for dictionaries.

Tuples are immutable sequences. Any attempt to assign to an index, such as config[1] = 9090, raises TypeError with a message like 'tuple' object does not support item assignment. The tuple itself remains unchanged. This is the correct behavior for the given code.

Using `config.get(key, 'N/A')` returns the supplied default when the key is absent, so no KeyError is raised. This satisfies the requirement to retrieve a value or fall back to 'N/A' for missing optional keys, while keeping the lookup a single, readable expression rather than a multi-line membership test.

The get() method returns the value for a given key if it exists, otherwise it returns a specified default value (or None if no default is provided). It does not raise an exception for missing keys, making it ideal for this scenario.

Positional arguments fill parameters left to right, so 'web01' binds to host. The keyword argument protocol='https' binds by name, skipping port, which therefore retains its default value of 8080. Python allows mixing positional and keyword arguments as long as no parameter receives two values and no required parameter is missing, so this call is valid and behaves exactly as described.

This function correctly returns a tuple of the number of records and the average salary, and it handles the empty dictionary case by returning (0, 0). It does not modify the input dictionary. The use of employees.values() assumes that the dictionary values are numeric salaries, which aligns with the scenario. This is the most robust and correct implementation.

When a function is defined with *args, any additional positional arguments passed to the function are gathered into a tuple named args. This allows the function to accept an arbitrary number of arguments. The tuple is immutable, so the collected arguments cannot be modified in place. This is a standard Python feature for flexible function signatures.

The *values parameter collects any number of positional arguments into a tuple named values. Inside the function, sum(values) can add them. This matches the scenario exactly: total(1, 2, 3) yields values as (1, 2, 3). It also allows zero arguments, in which case values is an empty tuple and sum returns 0.

Converting 'abc' with int() raises a ValueError, since the string holds no valid integer literal. The except clause names ValueError specifically, so it catches that exception and executes print('Invalid'). The try block aborts at the failing assignment, meaning nothing else runs before the handler outputs the required text.

dict.get returns the value for the given key, or the supplied default when the key is absent. Since 'b' is not in {'a': 1}, the method returns the default 0 rather than raising KeyError, leaving the dictionary unchanged.

Tuple unpacking assigns the first element to host, the second to port, and the third to secure, in order. The tuple has exactly three elements, matching the three target variables. This is a concise way to extract multiple values from a tuple. The operation succeeds without error, and the variables receive the corresponding values from the tuple.

.index() searches a tuple for a specified value and returns the zero-based position of its first occurrence, raising ValueError when absent. Tuples support this read-only lookup because it mutates nothing, satisfying the immutability constraint while providing the membership-position query the question requires.

When no exception occurs in the try block, the else block executes after the try block completes successfully. The finally block always executes, regardless of exceptions, so it runs last. The except block is skipped because no exception was raised. Thus the order is try, else, finally.

Negative indexing counts from the end, so t[-1] returns the final element, 5. This directly satisfies the stem's requirement for the last element, whereas t[0] gives the first and t[5] raises an IndexError because indices stop at 4.