OOP

Question 1

Initializer

Answer 1

__init__

Question 2

__init__

Answer 2

instance method that initializes a newly created object

Question 3

__dict__

Answer 3

dictionary or other mapping object used to store object’s attributes
class.__dict__ for class attributes
obj.__dict__ for instance attributes

Question 4

Attribute Access Flow

Answer 4

1. instance attributes
2. class attributes

Question 5

Method Object

Answer 5

class MyClass:
    def func(self):
        ...

obj.func - method object
class.func - function object

Question 6

Class Method

Answer 6

@classmethod
def method(cls):
    ... 

can be called from an instance

alternative constructor

Question 7

Static Method

Answer 7

@staticmethod
def method():
    ... 

can be called from an instance

Question 8

__class__

Answer 8

reference to the class of an object
self.__class__
obj.__class__

Question 9

Parent Class

Answer 9

base class
superclass

Question 10

Child Class

Answer 10

class DerivedClass(modname.BaseClass):
    ...

derived class
subclass

Question 11

Super

Answer 11

super(type, object_or_type=None)
object_or_type determines MRO

zero argument form only inside class definition

Question 12

Method Resolution Order

Answer 12

C3 linearization algorithm
class.__mro__ — tuple

Question 13

Mixin

Answer 13

a class that provides functionality to subclasses but is not intended to be instantiated itself

Question 14

Abstract Base Class

Answer 14

cannot be instantiated
blueprint for other classes
contains one or more abstract methods

from abc import ABC

class AbstractClass(ABC):
    ...

can have concrete methods

Question 15

Abstract Method

Answer 15

@abstractmethod

from abc import abstractmethod

must be overriden

Question 16

Inheritance Types

Answer 16

Single Inheritance
class inherits from a single base class

Multiple Inheritance
class inherits from multiple base classes

Multilevel Inheritance
derived class inherits from derived class

Hierarchical Inheritance
multiple classes inherit from a single base class

Hybrid Inheritance
multiple types of inheritance

Question 17

Private and Protected

Answer 17

protected
_protected_attribute
_protected_method
not imported by from module import *

private
__private_attribute
__private_method
AttributeError when trying to access from outside the class

Encapsulation

Question 18

Name Mangling

Answer 18

_ClassName__private_attribute
_ClassName__private_method

identifier is textually replaced
to avoid accidental overloading of methods and name conflicts with attributes of superclasses

Question 19

Abstract Class

Answer 19

class that contains one or more abstract methods and is intended to be subclassed

can be defined without using the abc module, typically by raising NotImplementedError in abstract methods

Question 20

Property

Answer 20

managed attribute

getter — to access the value of the attribute
setter — to set the value of the attribute
deleter — to delete the attribute

getter, setter, deleter methods create copy of property

class attribute that manages instance attributes

descriptor

Question 21

Property Function

Answer 21

property(fget=None, fset=None, fdel=None, doc=None)

return a property attribute
doc creates a docstring for the attribute

Question 22

Property Decorator

Answer 22

class MyClass:
    def ߺߺinitߺߺ(self, value):
        self._value = value

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, value)
        self._value = value

    @value.deleter
    def value(self):
        del self._value

only getter method name matters

Question 23

Del

Answer 23

del class.class_attribute
del class.method

del obj.instance_attribute

prevent removal:
- __delattr__()
- property deleter

Question 24

Data Class

Answer 24

from dataclasses import dataclass

@dataclass
class MyClass:
    attribute1: <Type1>
    attribute2: <Type2> = <default>
    ...
 
    def method(self):
        ...

implements:
.__init__()
.__repr__()
.__eq__()

@dataclass(init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False)

mutable namedtuple with defaults

Python 3.7
Python 3.6: pip install dataclasses

Question 25

Class Attribute

Answer 25

``` class MyClass(): value = ... ``` obj.value class.value shared across all instances

Question 26

Instance Attribute

Answer 26

``` class MyClass(): def ߺߺinitߺߺ(self, value): self.value = value ```

Question 27

Data Class Field

Answer 27

``` @dataclass class MyClass: attribute1: = field() ``` field() parameters: - default - default_factory - init - repr - hash - compare - metadata - kw_only

Question 28

Descriptor

Answer 28

object that defines at least one method of the descriptor protocol ``` class Descriptor: def ߺߺgetߺߺ(self, obj, objtype=None): return ``` to use, must be stored as a class variable: ``` class MyClass: attribute = Descriptor() ``` **obj** is an instance of MyClass **objtype** is the class MyClass optionally can have a __set_name__() method every instance shares descriptor instance dynamic lookup lazy properties

Question 29

Metaclass

Answer 29

class that controls creation and behavior of other classes ``` class MyClass(base1, base2, metaclass=MyMeta): ... ``` type PEP 3115

Question 30

Property Inheritance

Answer 30

``` class BaseClass: def ߺߺinitߺߺ(self, value): self._value = value @property def value(self): return self._value ``` for a single method: ``` class DerivedClass(BaseClass): @BaseClass.value.setter def value(self, value) self._value = value ``` for multiple methods: ``` class DerivedClass(BaseClass): @BaseClass.value.getter def value(self) return self._value + 1 # property with modified getter is in DerivedClass @value.setter def value(self, value) self._value = value ``` or with `lambda self: self.` ``` class BaseClass: def ߺߺinitߺߺ(self, value): self._value = value def _get_value(self): return self._value def _set_value(self, value): self._value = value value = property(fget=lambda self: self._get_value(), fset=lambda self, value: self._set_value(value)) ``` ``` class DerivedClass(BaseClass): def _get_value(self): return super()._get_value() + 1 ```

Question 31

Descriptor Protocol

Answer 31

descr.__get__(self, obj, type=None) descr.__set__(self, obj, value) descr.__delete__(self, obj)

Question 32

Descriptor Types

Answer 32

only .__get__() – non-data descriptor has .__set__() or .__delete__() – data descriptor data descriptors: property non-data descriptors: classmethod, staticmethod

Question 33

Lookup Chain

Answer 33

- .__get__() of data descriptor - object's __dict__ - .__get__() of non-data descriptor - object type's __dict__ - object parent type's __dict__ (repeat for all parents) - AttributeError

Question 34

Singleton

Answer 34

class with only one instance None, True, False

Question 35

Class Decorator

Answer 35

class that implements **__call__** method ``` class ClassDecorator: def ߺߺinitߺߺ(self, func): self.func = func def ߺߺcallߺߺ(self, *args, **kwargs): result = self.func(*args, **kwargs) return result ``` Use cases: - function objects - decorators - callbacks - command pattern class-based decorator

Question 36

__call__

Answer 36

makes instance of a class callable

Question 37

Decorating Class

Answer 37

``` def decorator(cls): def wrapper(*args, **kwargs): instance = cls(*args, **kwargs) return instance return wrapper ```

Question 38

__slots__

Answer 38

explicitly declares instance attributes and prevents the creation of **__dict__** and **__wekref__** for instances - faster attribute access - space savings in memory ``` class MyClass: ⸏⸏slots⸏⸏ = (par1, par2) ``` special attribute class variable

Question 39

Instantiation

Answer 39

instance creator **.__new__()** instance initializer **.__init__()**

Question 40

Methods

Answer 40

methods are functions