For an infinite loop using the while construct, the typical condition used is while _______:

  • 1
  • FALSE
  • None of the above
  • TRUE
For creating an infinite loop using the 'while' construct, the typical condition used is 'while True:'. This condition ensures that the loop will continue running indefinitely since 'True' is always evaluated as true. Infinite loops can be useful in certain scenarios, such as running a server or a program that should run continuously.

Consider a situation where multiple methods in a class can be potentially overloaded. How does Python decide which one to execute?

  • Python chooses the overloaded method with the shortest name.
  • Python executes all overloaded methods simultaneously.
  • Python executes the method defined in the derived class, ignoring overloaded methods in base classes.
  • Python executes the overloaded method based on the arguments passed during the function call.
In Python, method overloading isn't supported in the traditional sense as in some other languages. Python decides which method to execute based on the arguments passed during the function call. It doesn't execute all overloaded methods simultaneously, and it doesn't consider the method name or the class hierarchy.

Which keyword is specifically used to terminate a loop prematurely?

  • break
  • exit
  • halt
  • terminate
The break keyword is used to prematurely terminate a loop in Python. When encountered, it exits the loop and continues with the next statement.

When using nested loops, the break statement will exit the _______ loop.

  • Current
  • Inner
  • Outer
  • Parent
The 'break' statement in Python is used to exit the innermost loop when used in nested loops. It terminates the loop in which it is placed, hence exiting the 'Inner' loop.

You are designing a Vector class to represent 2D vectors, and you want to add two vectors using the + operator. How would you implement this?

  • Create a new class, VectorAdder, to handle vector addition.
  • Implement a separate function, add_vectors(), for adding vectors.
  • Overload the + operator in the Vector class, so it combines the x and y components of the vectors.
  • Overload the += operator for the Vector class to support in-place addition of vectors.
The correct approach is to overload the + operator in the Vector class, allowing for a natural syntax for vector addition. This is a common operator overloading scenario.

Consider a loop that processes each item in a list. If you want to skip processing for specific items and continue with the next one, which statement would you use?

  • break
  • continue
  • pass
  • skip
To skip processing for specific items in a loop and continue with the next one, you would use the 'continue' statement. It allows you to bypass the current iteration and move on to the next item in the loop.

Which method would you use to get a list of all the keys in a dictionary?

  • d.items()
  • d.keylist()
  • d.keys()
  • d.values()
To get a list of all the keys in a dictionary 'd', you would use the d.keys() method. It returns a list of all the keys present in the dictionary.

The variables that are defined inside a function are referred to as _______ variables.

  • Global
  • Instance
  • Local
  • Non-local
Variables defined inside a function are known as 'local' variables. They are only accessible within that function's scope.

Which of the following is a recommended use case for custom context managers?

  • Basic arithmetic calculations.
  • Closing a file after reading/writing data
  • Sorting a list of integers.
  • Web scraping with BeautifulSoup.
A recommended use case for custom context managers is closing a file after reading or writing data. This ensures proper resource cleanup and prevents resource leaks when dealing with files.

You are writing a nested function, and you want to modify a variable from the outer function. However, you don't want this change to affect the global scope. How can you achieve this?

  • Use the global keyword
  • Use the local keyword
  • Use the nonlocal keyword
  • Use the private keyword
To modify a variable from an outer function without affecting the global scope, use the 'nonlocal' keyword. It allows you to access and modify the variable in the closest outer scope.