1 of 41

Friendly Python Classes

Ąžuolas Krušna | Nov 30 2024

Dataclasses, Operators, Composition

Hi everyone and welcome! My name is Ąžuolas and it means an oak tree in Lithuanian. Today I would like to share with you Friendly Python Classes! Such are classes that I have the most pleasure to work with! We will forge them using dataclasses, operators and composition.

After school I decided to study Physics but eventually I came to Software engineering. At the moment I work for KAYAK, for almost 7 years now, and Python has been one of my favorite tools to work with. And this is my first time speaking in a Python conference!��Okay, now I am curious. Please raise your hand if you have ever created a class in Python.��[A lot of hands] Okay, I can see a lot of hands.

[Few hands] Okay, I can see a few hands.

I hope to share something useful with you either way.

Alright, let’s get into it!

[Oak tree Image by rawpixel.com]

2 of 41

2

Agenda

Why do we need classes?
Instruments to create Friendly Classes
Definition of a Friendly Class
Examples of forging a friendly metric
Practice | Expand the functionality of the metric
Practice | Build a minimalistic analytical Cube

3 of 41

3

Why do we need classes?

No need
Help to organize code
Library is built with classes

Don’t inherit, e.g. Pandas
Inherit, e.g. Django

So why do we need classes in the first place?

In Python we don’t actually need them. But they help to organize code when the complexity of the app grows. And most good apps utilize classes. However, if we have a simple script, there is no need to have classes in Python.

And sometimes we might have to use classes because the library, that we wish to make use of, is built with classes. Yet when we use this library, we don’t necessarily need to inherit its classes.

For example, when we slice and dice data with the Pandas library, we don’t inherit its classes even though the library is built with classes.

On the contrary, when we use the web framework Django, we almost always inherit classes.

So you might ask: “Do I need to know how to create Friendly Python Classes if I only use them?”.

I would say that: “Not really but you might benefit from the knowledge”.

And if you are creating a Python application that would benefit from classes, then it is definitely good to know about them.

[Image source: https://realpython.com/python-classes/]

4 of 41

4

What instruments will we use to create a Friendly Class?

Dataclasses
Operator overloading
Composition over Inheritance

5 of 41

5

So how are these Friendly Python Classes?

Easy to understand and to talk to — easy to read and write
Understand each other without words — use mathematical operators*
Easy to reach — easy to call

All right, let’s now define Friendly Python Classes. Let’s look at them as to our friends in real life. Just like our friends:

They are easy to understand and to talk to — such classes are easy to read and write.
We understand each other without words — we can use mathematical operators between their objects.
They are easy to reach — such classes are easy to call.�

I have added an asterisk * on the second property because we don’t always need to understand each other without words, therefore we don’t always need to support mathematical operators. However, if we can benefit from them, it is a very neat benefit.

Having said that, we don’t need to hit every property of a Friendly Class for it to be considered friendly. Having one of the properties makes the class already friendly.

6 of 41

Easy to understand and to talk to — easy to read and write

6

7 of 41

7

Traditional way

0xa5739s987d8f9
MetricV1Revenue
MetricV1
<__main__.MetricV1 at 0x7e2ae0123df0

module

class

address in the memory

All right, let’s turn to code!

Here we have the traditional way of describing a class to which we can pass arguments when initializing.

We can pass an alias and a field to it. Let’s think of it as an analytical metric that we could later use to query an SQL-like database with.

Let’s create a Revenue metric by summing the values of a revenue column.

{Transition 1}

Okay. Do you know what the response will be if we now hit enter into the Python interpreter?

{Transition 2}

Please raise your hand if you think it will be A.

Who thinks it will be B?

Who thinks it will be C?

And who thinks it will be D?

That’s right, it is D! [Most of you were correct!]

{Transition 3}

We get the name of the module, name of the class and the address in the memory. It could be useful for a computer scientist but on the other hand the information is redundant, confusing and there is not much information about the object itself.

8 of 41

8

Friendlier

Version 2. Let’s have a look at a friendlier representation. For this we have to define the __repr__ dunder method of the class.

So we do, we define the method. We return the class and the arguments that were passed to it when creating the object.

By the way, dunder stands for double underscore.

And we create a Revenue metric again.

{Transition 1}

What do you think will the response be now?

{Transition 2}

It is just like we described. It is a much friendlier response right now. If we were to debug this object, only from its representation we could already know what class does it use and what arguments were passed to it.

I also wonder if you have noticed something interesting.

{Pause}

Yes, the object creation as well as the representation expressions are the same. Thus, we can easily re-create such an object using its representation. Ideally, that’s how the __repr__ method works.

9 of 41

9

Utilizing dataclasses

type-hints are necessary

This leads me to my next point. Let’s utilize dataclasses!

We can simply import and use it as a decorator above a class. It already has all the logic that we described earlier! It has even more logic but it is not relevant to us for this presentation.

{Transition 1}

Note that we have to type-hint the datatypes of the variables in order for the dataclass to turn them into class arguments.

{Transition 2}

We hit enter to see what is the interpreter going to answer us

{Transition 3}

and we get the same response as before.

We can see that a dataclass reduces us a lot of boilerplate code as well as supports us while debugging.

Now you could naturally ask me: “Ąžuolas, but do we always have to pass the arguments now? Can we not have default values or static class variables?”

To this I can answer that, yes, we can, we don’t have to pass variables that we know in advance and we can also set a default value for them.

But do you believe my word? Let’s check with the Python interpreter that I am not lying!

10 of 41

10

Default values in dataclasses

11 of 41

11

Static class variables in dataclasses

12 of 41

12

What about __init__?

13 of 41

Understand each other without words — use mathematical operators

13

14 of 41

14

Let’s divide!

15 of 41

15

Division example 1

16 of 41

16

Division example 2

17 of 41

Easy to reach — easy to call

17

18 of 41

18

Composition

Inheritance

19 of 41

19

Inherited metrics

20 of 41

20

Inherited metric objects

21 of 41

21

Inherited metric objects 2

22 of 41

22

Quick and simple; debug support

(+ - * /) — Revenue / Sessions returns RevenuePerSessions

Key Takeaway. Friendly Class

23 of 41

Practice time!

23

24 of 41

24

Division by metrics and numbers

25 of 41

25

Division by a number example

26 of 41

26

Division by strings

27 of 41

27

Number division by a metric

28 of 41

28

Number division by a metric illustration

3.14 / MetricRevenue =>

29 of 41

29

Number division by a metric example

30 of 41

30

Multiplication and division of metrics and numbers

31 of 41

31

RPM metric

32 of 41

32

Bounced sessions metric

33 of 41

33

Dimensions

34 of 41

34

Analytical Cube

35 of 41

35

Minerva Cube

36 of 41

36

SQL query

Then we print the SQL code of the cube and we get this neat SQL query.

In the end we defined 3 classes – a metric class, a dimension class and a cube class.

Out of the metric class

{Transition 1}

we created 4 metric objects from scratch and we derived

{Transition 2}

3 metric objects out of them and numbers.

{Transition 3}

Then we created 1 dimension object – month.

{Transition 4}

And 1 cube object – MinervaCube.

This Cube object is very easy to spawn and it gives us a neat SQL query that we can use to query and analyze data with.

We made all of this using Friendly Python Classes and with this we conclude the practical part.

Lastly, I can add that the full beauty of Friendly Python Classes blossoms when the number of objects as well as their entanglement grows.

To experience it, please try it yourself.

37 of 41

37

Summary

Why do we need classes? — no need but they help organizing code and sometimes libraries enforce it
Instruments to create Friendly Classes — dataclasses, operators, composition
Definition of Friendly Class — easy to understand and talk to, understands without words*, easy to reach
Examples of forging a friendly metric
Practice | Expanded the functionality of the metric
Practice | Built a minimalistic Analytical Cube

38 of 41

38

Luciano Ramalho (2022). Fluent Python: Clear, Concise, and Effective Programming (2nd ed.). O’Reilly. https://www.oreilly.com/library/view/fluent-python-2nd/9781492056348/
Brandon Rhodes. The Composition Over Inheritance Principle https://python-patterns.guide/gang-of-four/composition-over-inheritance/

Literature

39 of 41

39

Bonus exercises. Operators

Implement Metrics addition
Implement Metrics subtraction
Create a derivative Metric based on at least 2 mathematical operations with other Metrics
Implement Metrics addition with numbers
Implement Metrics subtraction with numbers

40 of 41

40

Run the code yourself

Google Colab Notebook can be found at GitHub @AzisK https://github.com/AzisK

41 of 41

41

Could you benefit from Friendly Classes?

Let’s chat!