Pierre Augier (LEGI), Cyrille Bonamy (LEGI), Eric Maldonado (Irstea), Franck Thollard (ISTerre), Christophe Picard (LJK), Loïc Huder (ISTerre)
# Object-oriented programming: inheritance
See https://docs.python.org/3/tutorial/classes.html
Python is also a Object-oriented language. Object-oriented programming is very useful and used in many libraries so it is very useful to understand how the simple Object-oriented mechanisms work in Python.
%% Cell type:markdown id: tags:
For some problems, Object-oriented programming is a very efficient paradigm. Many libraries use it so it is necessary to understand how it works in Python to really use these libraries.
...
...
@@ -77,10 +79,15 @@
The first line states that instances of the class `AdultBee` will be Python objects. The class `AdultBee` inherits from the class `object`.
The first line could have been replaced by the less explicit `class AdultBee:`. Actually, in Python 3, the classes that do not inherit explicitly from another class automatically inherit from the class `object`.
-`kind` and `limit_age` are **class variables**,
-`mother`, `father`, `tag` and `living` are **instance variables**,
-`__init__` is a **"special" method**,
-`act_and_envolve` and `die` are **methods**.
%% Cell type:markdown id: tags:
### Instantiation of a class
...
...
@@ -136,12 +143,13 @@
Attributes and methods whose names start with `_` are said to be "protected". It is just a name convention. It tells the users that they should not use these objects directly.
%% Cell type:markdown id: tags:
### Warning for C++ users
`__init__` is NOT the constructor. The real constructor is `__new__`. This method is called to really create the Python object and it really returns the object. Usually, we do not need to redefine it. Python `__init__` and C++ constructor have to be used in very different ways. Only the `__init__` method of the class is automatically called by Python during the instantiation. Nothing like the Russian dolls C++ mechanism.
### Warning for C++ developers
`__init__` is NOT the constructor. The real constructor is `__new__`. This method is called to really create the Python object and it really returns the object. Usually, we do not need to redefine it. Python `__init__` and C++ constructor have to be used in very different ways. Only the `__init__` method of the class is automatically called by Python during the instantiation. Nothing like the Russian dolls C++ mechanism. All methods in Python are effectively virtual.
%% Cell type:markdown id: tags:
### Use the objects (instances)
...
...
@@ -170,11 +178,11 @@
## Inheritance
%% Cell type:markdown id: tags:
To indicate the dependency to another class, we put the parent class in parenthesis in the definition. The class `QueenBee` inherits from the class `AdultBee`
To indicate the dependency to another class, we put the parent class in parenthesis in the definition. The class `QueenBee` inherits from the class `AdultBee`
%% Cell type:code id: tags:
``` python
classQueenBee(AdultBee):
...
...
@@ -289,21 +297,22 @@
def__init__(self):
pass
classStudent(Person):
role='student'
@classmethod
defshow_role(cls):
print('The role for this class is '+
cls.role+'.')
Student.show_role()
```
%% Cell type:markdown id: tags:
### "Static methods"
### "Static methods" and class variables
For some situation we don't even need to explicitly use the class or an instance. We can use static methods.
%% Cell type:code id: tags:
...
...
@@ -321,233 +330,12 @@
```
%% Cell type:code id: tags:
``` python
p1=IdPerson('Pierre')
p1=IdPerson('Maya')
p2=IdPerson('Cyrille')
p3=IdPerson('Olivier')
p4=IdPerson('Franck')
IdPerson.show_nb_person()
```
%% Cell type:markdown id: tags:
## Do it yourself
At the end of the last presentation, we asked the following question about our weather stations measuring wind and temperature:
> What if we now have a weather station that also measure humidity ? Do we have to rewrite everything ?
Give your own answer by doing the following tasks:
- Write a class `HumidWeatherStation` inheriting `WeatherStation` (code reproduced below) to implement a new attribute to store the humidity measurements.
- Write a function `humidity_at_max_temp` that returns the value of the humidity at the maximal temperature. Use the fact that `HumidWeatherStation` inherits from `WeatherStation` and therefore can use the method `arg_max_temp` previously implemented !
-*Advanced*: Overloadg the methods of `WeatherStation` to take humidity into account when computing percieved temperatures `Tp`. For simplicity, we will assume that `Tp = Tw + 5*humidity` with `Tw` the temperature computed with the wind chill effect.
-*Advanced*: Write tests for this new class
%% Cell type:code id: tags:
``` python
# Code to use for the DIY
classWeatherStation(object):
""" A weather station that holds wind and temperature """
def__init__(self,wind,temperature):
""" initialize the weather station.
Precondition: wind and temperature must have the same length
:param wind: any ordered iterable
:param temperature: any ordered iterable"""
self.wind=[xforxinwind]
self.temp=[xforxintemperature]
iflen(self.wind)!=len(self.temp):
raiseValueError(
"wind and temperature should have the same size"
)
defperceived_temp(self,index):
""" computes the perceived temp according to
https://en.wikipedia.org/wiki/Wind_chill
i.e. The standard Wind Chill formula for Environment Canada is:
# As we overloaded perceived_temp, the rest of the class features work with the new behaviour
print(singapore.perceived_temps())
print(singapore.max_temp(perceived=True))
```
%% Cell type:markdown id: tags:
In this case, we used inheritance to create the new object (`HumidWeatherStation`) to:
- Add new features (`humidity_at_max_temp`) to an existing object without rewritting the common features
- Define new behaviours for features already present (`perceived_temp`) that integrate well with the structure in place
For such needs, think about inheritance.
%% Cell type:markdown id: tags:
## Do it yourself (advanced)
- Write a class named `MovingObject` that has at least one attribute `position` and implements two functions `start()` and `stop()`. These 2 functions could just print for example "starting" and "stoping" (or they could do more funny things)...
- Write another class named `Car` that inherits `MovingObject` and overload start and stop functions.
- Use the classes (instantiate objects and use them).
- Options : add a static method in Car class that returns the number of cars.
We use [invoke](https://www.pyinvoke.org/)(`pip install invoke`) to build and run the benchmarks. The full requirements can be installed with `pip install -r requirements.txt`.
We use [invoke](https://www.pyinvoke.org/) to build and run the benchmarks.
See [how to get autocompletion with invoke](http://docs.pyinvoke.org/en/1.2/invoke.html?highlight=completion#cmdoption-print-completion-script).
