Classes

Question 1

Define class attribute

Answer 1

class Human:
  species = "H. sapiens"

WARNING - when using mutable types, single instance is shared by all the objects!

Question 2

Define instance attribute

Answer 2

  def \_\_init\_\_(self, name):
    self.name = name

Question 3

Define private instance attribute

Answer 3

  def \_\_init\_\_(self, name):
    # Private (_ is only suggestion, not enforced in any way)
    self._age = 0
    # Private (\_\_ triggers  name mangling, field is renamed to _Human\_\_update to prevent collisions in child classes)
    self.\_\_update(iterable)

Question 4

Define instance method

Answer 4

  def say(self, msg):
    return msg

Question 5

Define class method

Answer 5

  @classmethod
  def get_species(cls):
    return cls.species

Question 6

Define static method

Answer 6

  @staticmethod
  def grunt():
    return "*grunt*"

Question 7

Define Getter, setter and deleter called age

Answer 7

  # Getter (access by obj.age)
  @property
  def age(self):
    return self._age

  # Setter
  @age.setter
  def age(self, age):
    self._age = age

  # Deleter
  @age.deleter
  def age(self):
    del self._age

Question 8

Construct new object of Human class

Answer 8

i = Human(name="Ian")

Question 9

Define struct (POCO) class in python

Answer 9

from dataclasses import dataclass

@dataclass
class Employee:
    name: str
    dept: str
    salary: int

Question 10

Initialize parent from derived class ctor

Answer 10

super().\_\_init\_\_(name)

Question 11

Check if sup is instance of class Human

Answer 11

isinstance(sup, Human);

Question 12

Check if sup is derived from Human

Answer 12

issubclass(sup, Human);

Question 13

Check type of sup

Answer 13

type(sup);

Question 14

Define class Superhero that derives from Human

Answer 14

class Superhero(Human):
pass

Question 15

Define class Superhero that derives from Human and Bat

Answer 15

class Batman(Superhero, Bat):
pass

Question 16

Get the order in which classes are searched for an attribute or method.
What is the full name of that property?

Answer 16

Batman.\_\_mro\_\_

Method Resolution Order

Question 17

Define class as iterator

Answer 17

class Reverse:
    # Called by iter()
    def \_\_iter\_\_(self):
        return self

    # Iterator must have a next method
    def \_\_next\_\_(self):
        if self.index == 0:
            raise StopIteration
        return data;

Question 18

Make hashable dataclass (that can be used as map key for example)

Answer 18

@dataclass(frozen=True)
class ServerConfig:
  host: str
  port: int = 8080

Question 19

What are benefits of dataclass over reguklar class for simple structures

Answer 19

Can have order / be readonly

@dataclass(order=True, frozen=True)

Auto-generated \_\_repr\_\_

print(config)
# Output: ServerConfig(host='localhost', port=8080, active_plugins=['auth', 'cache'])

Easy conversion to dict (great for serialization)

print(asdict(config))

Built-in equality check (compares values, not identity)

assert config == ServerConfig("localhost", active_plugins=["auth", "cache"])

Question 20

What are slots in class, when and how to use them?

Answer 20

• \_\_slots\_\_ is a class-level optimization that tells Python to not use a dynamic \_\_dict\_\_ for instance attributes.
• Instead, it reserves a fixed amount of memory for a specific set of attributes.

```python
class SlottedClass:
# Explicitly declare which attributes this class can have
__slots__ = (‘x’, ‘y’)

def __init__(self, x, y):
self.x = x
self.y = y

obj = SlottedClass(10, 20)
obj.z = 99 # AttributeError: ‘SlottedClass’ object has no attribute ‘z’
~~~

• High Cardinality: You are creating massive numbers of small objects (e.g., Points in a 3D mesh, Nodes in a large Graph, Rows in a custom DataFrame).
• Strict Schema: You want to enforce a strict structure and prevent developers (or yourself) from accidentally adding typos as new attributes (e.g., self.nmae = “Jon”).

Question 21

What are trade-off and gotachas of using slots in class?

Answer 21

• You cannot add new attributes to instances at runtime (unless you explicitly add \_\_dict\_\_ to slots).
• Inheritance: Slots do not automatically propagate to subclasses. If class B inherits from slotted class A but doesn’t define \_\_slots\_\_ itself, B will have a \_\_dict\_\_.
• Multiple Inheritance: You cannot inherit from multiple classes that both define non-empty \_\_slots\_\_ (layout conflict).