What is the key characteristic of an anonymous or lambda function in Python?
Explanation
This question tests the definition and primary constraint of lambda functions in Python. Their main purpose is to create small, inline functions without the full `def` syntax, which is particularly useful in data analysis for operations like sorting or mapping.
Other questions
What is the primary characteristic of a Python tuple as a data structure?
What is the result of the following Python code snippet? tup = tuple(['foo', [1, 2], True]); tup[1].append(3)
In Python, what does the special syntax `*rest` do when unpacking a tuple or list?
What is a key difference between the `extend` method and using the `+` operator for combining lists?
When using slice notation on a sequence like `seq[start:stop]`, which element is not included in the result?
What is the output of the slice notation `seq[::-1]` on a list `seq`?
In the context of Python dictionaries, what is the concept of 'hashability' related to?
What is the purpose of the `setdefault` dictionary method?
How can you create a set from the list `[2, 2, 2, 1, 3, 3]` in Python?
Given two sets, `a = {1, 2, 3, 4, 5}` and `b = {3, 4, 5, 6, 7, 8}`, what is the result of `a.intersection(b)`?
What does the built-in Python function `enumerate` return when used on a collection?
When using the `zip` function on multiple sequences of different lengths, what determines the number of tuples produced?
What is the purpose of the `reversed` function in Python?
What is the result of the list comprehension `[x.upper() for x in strings if len(x) > 2]` where `strings` is `["a", "as", "bat", "car", "dove", "python"]`?
What is the primary syntactical difference between a list comprehension and a set comprehension?
Given the nested list `some_tuples = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]`, what is the result of the nested list comprehension `[x for tup in some_tuples for x in tup]`?
What value is returned by a Python function that reaches its end without an explicit `return` statement?
When a function returns multiple values, such as `return a, b, c`, what data structure is actually being returned?
How does a generator function differ from a normal function in Python?
What is the syntax for creating a generator expression in Python?
What is the primary function of the `itertools.groupby` generator?
In a `try...except...finally` block, when is the code inside the `finally` clause executed?
What is the primary advantage of using the `with` statement when working with files (e.g., `with open(...) as f:`)?
What does the file open mode 'x' do in Python?
What is the difference between opening a file in text mode (e.g., 'r') versus binary mode (e.g., 'rb')?
If `f1 = open(path)` is opened in text mode and `f2 = open(path, mode='rb')` is opened in binary mode, and both call `read(10)`, why might `f1.tell()` and `f2.tell()` return different values?
What is a potential issue when using the `seek()` method on a file opened in text mode with a multi-byte encoding like UTF-8?
Consider the code `b = ["saw", "small", "He", "foxes", "six"]; b.sort(key=len)`. What is the final state of the list `b`?
What is the primary difference between a list's `sort()` method and Python's built-in `sorted()` function?
Given `tuples = zip(range(5), reversed(range(5)))`, what will be the result of `dict(tuples)`?
What is the function of the `collections.defaultdict` class?
If `c = a.copy()` and `a` and `b` are sets, what is the effect of the in-place operation `c |= b`?
Why might a programmer choose to use a generator expression `(x ** 2 for x in range(100))` instead of a list comprehension `[x ** 2 for x in range(100)]`?
In a Python function definition like `def my_func(x, y, z=1.5):`, what is `z=1.5` an example of?
What does the `global` keyword do inside a Python function?
Why is it possible to pass functions as arguments to other functions in Python?
In a `try...except...else` block, when does the `else` block execute?
To catch multiple specific exception types in a single `except` block, what syntax should be used?
What does the `list` built-in function do when applied to a generator expression?
If `seq = [7, 2, 5, 1, 3]`, what is the result of `a = sorted(seq)`?
What happens when you use the `pop` method on a dictionary, like `d.pop("key")`?
Which method is used to merge one dictionary into another, modifying the first dictionary in-place?
What is the result of using the `*` operator on a tuple, as in `('foo', 'bar') * 4`?
When unpacking a tuple using `a, b, *_ = values`, what is the purpose of the underscore `_` variable?
What is the computational cost of the list `insert` method compared to `append`?
When checking if a value is in a list versus a set, which is typically faster for large collections and why?
Given the list of lists `all_data = [["John", "Emily"], ["Maria", "Natalia"]]`, what is the result of `[name for names in all_data for name in names if name.count("a") >= 2]`?
How can you unpack the tuple `values = (1, 2, 3, 4, 5)` so that variable `a` is 1, `b` is 2, and the rest of the values are discarded?
What would the function `isiterable` defined in the text as `def isiterable(obj): try: iter(obj); return True; except TypeError: return False` return for the input `5`?