u8-script-classes Flashcards
What is the difference between these two class method definitions?\ndef look(self, new_orientation):\n self.orientation = new_orientation\n\n@property\ndef orientation(self):\n return self._orientation
The first is a regular method that modifies an attribute, while the second is a property decorator that allows controlled access to an attribute. Properties are accessed like attributes (obj.orientation) rather than called like methods (obj.look())
How do you call a parent class’s method from a child class?\nShow example code.
Use super() to call the parent’s method:\nsuper().look(new_orientation)\nThis allows you to extend parent functionality while reusing existing code
What does this code demonstrate about class inheritance?\nclass OwlFace(Face):\n def look(self, new_orientation):\n if new_orientation == “ahead”:\n self.orientation = new_orientation\n else:\n super().look(new_orientation)
It shows method overriding with parent method reuse: The child class extends the parent’s functionality (adds “ahead” orientation) while reusing the parent’s implementation for other cases
What is the purpose of raising NotImplementedError?\ndef transform(self, list):\n raise NotImplementedError
It indicates an abstract method that must be implemented by child classes. The base class provides the interface but leaves the implementation to its subclasses
How do you implement a class attribute vs an instance attribute?\nclass Product:\n stock = 0 # class attribute\n def __init__(self):\n self.price = 0 # instance attribute
Class attributes (stock) are shared among all instances of the class, while instance attributes (price) are unique to each instance. Class attributes are defined directly in the class body
What is the difference between a private and protected method in Python?\ndef _transform(self) vs def __transform(self)
Methods prefixed with single underscore (_transform) are protected (convention for “internal use”), while double underscore (__transform) triggers name mangling for better encapsulation
How do you implement a property with both getter and setter?\nclass Product:\n @property\n def price(self):\n return self._price\n @price.setter\n def price(self, price):\n self._price = price
Use @property decorator for getter and @attribute.setter for setter. This allows controlled access to attributes and validation of values
What does this code demonstrate about class hierarchies?\nclass AudioBook(Product):\n def __init__(self, price, author, title, duration):\n super().__init__(price)\n self._author = author\n self._title = title
It shows proper class initialization in inheritance: 1) Child class calls parent’s __init__ using super() 2) Then initializes its own attributes 3) Maintains the inheritance chain
How do you implement method chaining with transformers?\nat = AbsTransformer()\nat_lists = at.transform(lists)\nst = ScaleTransformer(1, 10)\nst_lists = st.transform(at_lists)
Each transformer processes the output of the previous transformer. This demonstrates the transformer pattern where each step modifies the data and passes it to the next step
What is the purpose of the ABC (Abstract Base Class) import?\nfrom abc import ABC, abstractmethod\nclass Transformer(ABC):
ABC provides a way to define abstract base classes in Python. Classes inheriting from ABC can define abstract methods that must be implemented by concrete subclasses
How do you implement a class method that modifies a class attribute?\nclass Book(Product):\n def __init__(self, price, author, title):\n super().__init__(price)\n Book.stock += 1
Use the class name (Book.stock) to access and modify class attributes. This affects all instances of the class
What’s the difference between these transformer implementations?\nclass NormalizeTransformer(ScaleTransformer):\n def __init__(self):\n super().__init__(min_=0, max_=1)\n\nclass AbsTransformer(Transformer):\n def transform(self, list):\n return [abs(i) for i in list_]
NormalizeTransformer specializes its parent by fixing parameters (min_=0, max_=1), while AbsTransformer implements a completely new transformation. This shows two different ways to extend classes
How do you implement type hints for class methods?\ndef transform(self, lists) -> list[list]:\n return [self.transform(list) for list_ in lists]
Use -> to specify return type. list[list] indicates a list of lists. Parameter types can be specified with parameter: type syntax
What is the purpose of the @abstractmethod decorator?
It marks a method as abstract, requiring all non-abstract child classes to implement it. This enforces a contract that subclasses must follow
How do you handle attribute access control in Python classes?\nclass AudioBook:\n def __init__(self, price):\n self._price = price # protected\n self.__secret = None # private
Use single underscore (_price) for protected attributes (convention) and double underscore (__secret) for private attributes (name mangling). Properties can provide controlled access
