Python Classes and OOP With AI

End-of-lesson check

15 questions · take it digitally for instant feedback at tendril.neural-forge.io/learn/quiz/end-progx-python-oop-creators

1. What is the bug in this code? class Counter: count = []

   1. The list will cause a memory leak when the program exits
   2. The code will run significantly slower than using a local variable
   3. The type hint for count is wrong and will cause a runtime error
   4. The empty list is created once and shared across all instances, so all counters see the same history

2. What does using `default_factory=list` in a dataclass field accomplish?

   1. It enforces that the field must always contain a list, never another type
   2. It calls the provided function each time a new instance is created, producing a fresh list for each instance
   3. It caches the list so all instances share the same reference
   4. It converts the list to a special factory object that can create other types

3. A developer wants to model a 'Vehicle' that 'has a' Engine. Should they use inheritance or composition?

   1. Either works equally well with no difference in outcome
   2. Composition is not available in Python
   3. Inheritance — vehicles are a type of engine
   4. Composition — the vehicle contains an engine as a part, not because it is an engine

4. What does the @dataclass decorator automatically generate for a class?

   1. __init__, __repr__, and __eq__ methods so you don't have to write them manually
   2. A full GUI interface with buttons and input fields
   3. Type checking that prevents any type errors at runtime
   4. A database connection that persists across all instances

5. Why does the lesson advise that 'inheritance is a last resort, not a first move'?

   1. Deep inheritance trees become hard to change and test; simpler alternatives often work better
   2. Python does not support inheritance properly
   3. Inheritance is slower than other approaches in Python
   4. Inheritance was removed from the language

6. A student writes: class Person: def speak(self): print('Hello'). What is 'self' in this context?

   1. A global variable that always contains the most recently created object
   2. A reference to the specific instance the method was called on
   3. A keyword that must be omitted when calling the method
   4. A reference to the Person class itself, not an instance

7. What problem does using a dataclass solve compared to a regular class with just attributes?

   1. It prevents any attribute from ever being changed after creation
   2. It eliminates the need to write boilerplate code for __init__, __repr__, and __eq__
   3. It makes the code run at least twice as fast
   4. It automatically connects to a database to persist the data

8. Why might an AI coding assistant suggest deep inheritance trees when writing Python code?

   1. AI models often default to traditional OOP patterns from older languages, but composition is usually simpler in Python
   2. Inherited code runs faster than composed code
   3. Python requires inheritance for any code reuse
   4. AI has a bug that always generates inheritance

9. What is the fundamental idea behind 'composition over inheritance'?

   1. Composition means writing less code overall
   2. Inheritance should be replaced with global variables
   3. Rather than inheriting behavior, you hold a reference to an object that provides the behavior you need
   4. Instead of using classes, you should only use functions

10. What does it mean that 'classes tie state to behavior'?

    1. Behavior should be global functions, and state should be global variables
    2. Classes combine data (state) with functions (methods) that operate on that data in one unit
    3. Classes should only contain state, never behavior, for safety
    4. The terms state and behavior mean the same thing in Python

11. When is inheritance the right choice in Python?

    1. Whenever you need two classes to share any functionality
    2. When one type genuinely is a specialized version of another type (an 'is-a' relationship)
    3. When you need the code to run as fast as possible
    4. When you want to reuse code but are unsure what pattern fits

12. What happens if you define a dataclass field with `default=` instead of `default_factory=` for a mutable value like a list?

    1. All instances will share the same list object, causing unexpected shared state
    2. The list will be automatically converted to an immutable tuple
    3. The code will fail with a type error at runtime
    4. The default value will be ignored and the field will be required

13. What distinguishes a method from a regular function defined at module level?

    1. A method cannot be called outside of the class
    2. A method is defined inside a class and automatically receives the instance as its first argument
    3. A method can only return numbers, not strings or other types
    4. A method runs faster because it's stored in the class

14. A programmer needs a class that only holds data fields with no custom behavior. What Python feature is most appropriate?

    1. A regular class with an empty __init__ that does nothing
    2. A dataclass, because it automatically generates __init__, __repr__, and __eq__ based on the fields
    3. An interface, because it defines only data
    4. A function, because classes cannot hold just data

15. What is wrong with this code: def greet(names=[]): print(names)?

    1. The function will run infinitely
    2. The default list is created once at function definition, so all calls share the same list
    3. Default arguments cannot be used in Python
    4. The code is correct and will work as expected