9.2. OOP Methods

9.2.1. Rationale

  • Methods are functions in the class

  • First argument is always instance (self)

  • While calling function you never pass self

  • Prevents copy-paste code

  • Improves readability

  • Improves refactoring

  • Decomposes bigger problem into smaller chunks

method

Functions in the class which takes instance as first argument (self)

Syntax:

>>> class MyClass:
...     def mymethod(self):
...         ...
>>>
>>> my = MyClass()
>>> my.mymethod()

9.2.2. Methods Without Arguments

Methods without arguments:

>>> class Astronaut:
...     def say_hello(self):
...         print('My name... José Jiménez')
...
...
>>> jose = Astronaut()
>>> jose.say_hello()
My name... José Jiménez

9.2.3. Methods With Required Argument

Methods with required argument:

>>> class Astronaut:
...     def say_hello(self, name):
...         print(f'My name... {name}')
>>>
>>>
>>> jose = Astronaut()
>>>
>>> jose.say_hello(name='José Jiménez')
My name... José Jiménez
>>>
>>> jose.say_hello('José Jiménez')
My name... José Jiménez
>>>
>>> jose.say_hello()
Traceback (most recent call last):
TypeError: say_hello() missing 1 required positional argument: 'name'

9.2.4. Methods With Optional Argument

Methods with arguments with default value:

>>> class Astronaut:
...     def say_hello(self, name='Unknown'):
...         print(f'My name... {name}')
>>>
>>>
>>> jose = Astronaut()
>>>
>>> jose.say_hello(name='José Jiménez')
My name... José Jiménez
>>>
>>> jose.say_hello('José Jiménez')
My name... José Jiménez
>>>
>>> jose.say_hello()
My name... Unknown

9.2.5. Assignments

Code 9.3. Solution
"""
* Assignment: OOP Method Syntax
* Complexity: easy
* Lines of code: 3 lines
* Time: 3 min

English:
    1. Use data from "Given" section (see below)
    2. Define class `Calculator`
    3. Define method `add` in class `Calculator`
    4. Method `add` take `a` and `b` as arguments
    5. Method returns sum of `a` and `b`
    6. Compare result with "Tests" section (see below)

Polish:
    1. Użyj danych z sekcji "Given" (patrz poniżej)
    2. Zdefiniuj klasę `Calculator`
    3. Zdefiniuj metodę `add` w klasie `Calculator`
    4. Metoda `add` przyjmuje `a` i `b` jako argumenty
    5. Metoda zwraca sumę `a` i `b`
    6. Porównaj wyniki z sekcją "Tests" (patrz poniżej)

Tests:
    >>> from inspect import isclass, ismethod
    >>> assert isclass(Calculator)
    >>> calc = Calculator()
    >>> assert ismethod(calc.add)
    >>> calc.add(1, 2)
    3
"""


Code 9.4. Solution
"""
* Assignment: OOP Method Mean
* Complexity: easy
* Lines of code: 4 lines
* Time: 5 min

English:
    1. Use data from "Given" section (see below)
    2. Define class `Stats`
    3. Define method `mean()` in `Stats` class
    4. Method takes `data: list[float]` as an argument
    5. Method returns arithmetic mean of the `data`
    6. Returned value must me rounded to one decimal places
    7. Compare result with "Tests" section (see below)

Polish:
    1. Użyj danych z sekcji "Given" (patrz poniżej)
    2. Zdefiniuj klasę `Stats`
    3. Zdefiniuj metodę `mean()` w klasie `Stats`
    4. Metoda przyjmuje `data: list[float]` jako argument
    5. Metoda zwraca średnią arytmetyczną z `data`
    6. Zwracana wartość ma być zaokrąglona do jednego miejsca po przecinku
    7. Porównaj wyniki z sekcją "Tests" (patrz poniżej)

Hints:
    * `round()`

Tests:
    >>> from inspect import isclass, ismethod
    >>> assert isclass(Stats)
    >>> stats = Stats()
    >>> assert ismethod(stats.mean)
    >>> stats.mean([1, 2])
    1.5
    >>> stats.mean([5.8, 2.7, 5.1, 1.9])
    3.9
"""


Code 9.5. Solution
"""
* Assignment: OOP Method Call
* Complexity: easy
* Lines of code: 2 lines
* Time: 2 min

English:
    1. Use data from "Given" section (see below)
    2. Create instance of `Stats` class
    3. Iterate over `DATA` skipping header
    4. Separate features from label
    5. Call `mean()` method of `Stats` class passing list of features as an argument
    6. Define `result: list[float]` with list of means from each row
    7. Compare result with "Tests" section (see below)

Polish:
    1. Użyj danych z sekcji "Given" (patrz poniżej)
    2. Stwórz instancję klasy `Stats`
    3. Iteruj po `DATA` pomijając nagłówek
    4. Rozdziel cechy od etykiety
    5. Wywołuj metodę `mean()` klasy `Stats` przekazując listę features jako argument
    6. Zdefiniuj `result: list[float]` z listą średnich każdego z wierszy
    7. Porównaj wyniki z sekcją "Tests" (patrz poniżej)

Hints:
    * `round()`

Tests:
    >>> assert type(result) is list
    >>> assert all(type(x) is float for x in result)
    >>> result
    [3.9, 2.5, 3.5, 4.1, 3.9, 2.4]
"""


# Given
DATA = [('Sepal length', 'Sepal width', 'Petal length', 'Petal width', 'Species'),
        (5.8, 2.7, 5.1, 1.9, 'virginica'),
        (5.1, 3.5, 1.4, 0.2, 'setosa'),
        (5.7, 2.8, 4.1, 1.3, 'versicolor'),
        (6.3, 2.9, 5.6, 1.8, 'virginica'),
        (6.4, 3.2, 4.5, 1.5, 'versicolor'),
        (4.7, 3.2, 1.3, 0.2, 'setosa')]


class Stats:
    def mean(self, data):
        result = sum(data) / len(data)
        return round(result, 1)