Vizualizare sursă pentru „Lab 2”

= Lab 2 — Object-Oriented Programming in Python =

== Objectives ==

This laboratory introduces object-oriented programming in Python to students who already know object-oriented programming in C++.

The goal is not to relearn classes, inheritance, encapsulation or polymorphism, but to understand how these concepts are expressed in Python and how Python's object model differs from C++.

After completing this laboratory, you should be able to:

* define and instantiate Python classes;
* understand the role of <code>self</code>;
* distinguish between instance and class attributes;
* define constructors and methods;
* understand Python's conventions for public, protected and private members;
* use properties;
* use class methods and static methods;
* use inheritance and <code>super()</code>;
* understand method overriding and duck typing;
* prefer composition where appropriate;
* use <code>@dataclass</code>;
* implement common special methods such as <code>__str__</code>, <code>__repr__</code>, <code>__eq__</code>, <code>__len__</code> and <code>__iter__</code>;
* recognize common C++ habits that should not be translated directly into Python.

Throughout this laboratory, familiar C++ constructs are presented next to their Python equivalents.

__TOC__

== 1. Defining a class ==

A simple class declaration is similar conceptually, but Python uses <code>class</code> followed by an indented block.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Student {
public:
    std::string name;
    int age;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Student:
    pass
</syntaxhighlight>
|}

The Python class above does not yet define any attributes. In Python, instance attributes are commonly created in the constructor.

== 2. Creating objects ==

Creating an object is straightforward in both languages.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
Student student;
</syntaxhighlight>
|
<syntaxhighlight lang="python">
student = Student()
</syntaxhighlight>
|}

In Python, the class itself is called like a function to create a new instance.

== 3. Constructors ==

In C++, constructors have the same name as the class.

Python uses the special method <code>__init__()</code>.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Student {
public:
    Student(
        const std::string& name,
        int age
    )
        : name(name),
          age(age)
    {
    }

    std::string name;
    int age;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age
</syntaxhighlight>
|}

An object can then be created as follows:

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
Student student("Alice", 21);
</syntaxhighlight>
|
<syntaxhighlight lang="python">
student = Student("Alice", 21)
</syntaxhighlight>
|}

== 4. The meaning of self ==

The first parameter of an instance method is conventionally named <code>self</code>.

It refers to the current object.

Conceptually, it plays a role similar to <code>this</code> in C++.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Counter {
public:
    void increment()
    {
        this->value++;
    }

private:
    int value = 0;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Counter:
    def __init__(self):
        self.value = 0

    def increment(self):
        self.value += 1
</syntaxhighlight>
|}

There is one important syntactic difference:

{| class="wikitable" style="width:100%;"
! C++
! Python
|-
| <code>this</code> is implicit in the method parameter list
| <code>self</code> is explicitly written as the first parameter
|-
| <code>this-&gt;value</code>
| <code>self.value</code>
|}

When calling the method, <code>self</code> is not supplied explicitly:

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
counter.increment();
</syntaxhighlight>
|
<syntaxhighlight lang="python">
counter.increment()
</syntaxhighlight>
|}

Python automatically passes the object as the first argument.

== 5. Instance attributes ==

Instance attributes belong to individual objects.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Student {
public:
    Student(std::string name)
        : name(name)
    {
    }

    std::string name;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Student:
    def __init__(self, name):
        self.name = name
</syntaxhighlight>
|}

Each instance has its own value:

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
Student a("Alice");
Student b("Bob");

std::cout << a.name << "\n";
std::cout << b.name << "\n";
</syntaxhighlight>
|
<syntaxhighlight lang="python">
a = Student("Alice")
b = Student("Bob")

print(a.name)
print(b.name)
</syntaxhighlight>
|}

== 6. Class attributes ==

Python class attributes are shared by all instances of the class.

They are similar to static data members in C++.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Student {
public:
    static int count;

    Student()
    {
        count++;
    }
};

int Student::count = 0;
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Student:
    count = 0

    def __init__(self):
        Student.count += 1
</syntaxhighlight>
|}

Usage:

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
Student a;
Student b;

std::cout << Student::count;
</syntaxhighlight>
|
<syntaxhighlight lang="python">
a = Student()
b = Student()

print(Student.count)
</syntaxhighlight>
|}

Class attributes should normally be accessed through the class when they represent class-wide state.

== 7. Instance methods ==

Instance methods operate on one particular object.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Rectangle {
public:
    Rectangle(double width, double height)
        : width(width), height(height)
    {
    }

    double area() const
    {
        return width * height;
    }

private:
    double width;
    double height;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height
</syntaxhighlight>
|}

Calling the method:

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
Rectangle r(3.0, 4.0);

std::cout << r.area();
</syntaxhighlight>
|
<syntaxhighlight lang="python">
r = Rectangle(3.0, 4.0)

print(r.area())
</syntaxhighlight>
|}

== 8. Public, protected and private members ==

C++ enforces access control through <code>public</code>, <code>protected</code> and <code>private</code>.

Python primarily uses naming conventions.

{| class="wikitable" style="width:100%;"
! Meaning
! C++
! Python convention
|-
| public
| <code>public:</code>
| <code>name</code>
|-
| internal / protected-like
| <code>protected:</code>
| <code>_name</code>
|-
| private
| <code>private:</code>
| <code>__name</code>
|}

Example:

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Account {
public:
    std::string owner;

protected:
    int account_id;

private:
    double balance;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Account:
    def __init__(self):
        self.owner = ""
        self._account_id = 0
        self.__balance = 0.0
</syntaxhighlight>
|}

A single leading underscore means:

<blockquote>
This member is intended for internal use.
</blockquote>

It is a convention, not an access restriction.

== 9. Name mangling ==

Names beginning with two underscores are transformed internally by Python.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Account {
private:
    double balance = 0.0;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Account:
    def __init__(self):
        self.__balance = 0.0
</syntaxhighlight>
|}

Python internally transforms:

<syntaxhighlight lang="text">
__balance
</syntaxhighlight>

into a name similar to:

<syntaxhighlight lang="text">
_Account__balance
</syntaxhighlight>

This mechanism is called '''name mangling'''.

It is primarily designed to avoid accidental name conflicts in subclasses. It is not a security mechanism.

== 10. Getters and setters ==

A direct C++ translation might use explicit getter and setter methods.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python — direct style
|-
|
<syntaxhighlight lang="cpp">
class Person {
public:
    int getAge() const
    {
        return age;
    }

    void setAge(int value)
    {
        if (value < 0) {
            throw std::invalid_argument(
                "age cannot be negative"
            );
        }

        age = value;
    }

private:
    int age = 0;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Person:
    def __init__(self):
        self._age = 0

    def get_age(self):
        return self._age

    def set_age(self, value):
        if value < 0:
            raise ValueError(
                "age cannot be negative"
            )

        self._age = value
</syntaxhighlight>
|}

The Python version works, but explicit getters and setters are usually not the preferred interface.

== 11. Properties ==

Python properties provide controlled attribute access while keeping normal attribute syntax.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Person {
public:
    int getAge() const
    {
        return age;
    }

    void setAge(int value)
    {
        if (value < 0) {
            throw std::invalid_argument(
                "age cannot be negative"
            );
        }

        age = value;
    }

private:
    int age = 0;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Person:
    def __init__(self):
        self._age = 0

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, value):
        if value < 0:
            raise ValueError(
                "age cannot be negative"
            )

        self._age = value
</syntaxhighlight>
|}

Usage:

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
Person p;

p.setAge(21);

std::cout << p.getAge();
</syntaxhighlight>
|
<syntaxhighlight lang="python">
p = Person()

p.age = 21

print(p.age)
</syntaxhighlight>
|}

The Python interface looks like direct attribute access even though validation is performed internally.

== 12. Do not create properties unnecessarily ==

In C++, private data members with getters and setters are common.

In Python, plain public attributes are acceptable when no validation or additional behavior is required.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++ style
! style="width:50%;" | Python style
|-
|
<syntaxhighlight lang="cpp">
class Point {
public:
    double getX() const
    {
        return x;
    }

    void setX(double value)
    {
        x = value;
    }

private:
    double x = 0.0;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Point:
    def __init__(self, x=0.0):
        self.x = x
</syntaxhighlight>
|}

A property can always be introduced later without changing how callers access the attribute.

== 13. Static methods ==

A static method does not operate on a particular instance.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Math {
public:
    static int square(int x)
    {
        return x * x;
    }
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Math:
    @staticmethod
    def square(x):
        return x * x
</syntaxhighlight>
|}

Usage:

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
int result = Math::square(5);
</syntaxhighlight>
|
<syntaxhighlight lang="python">
result = Math.square(5)
</syntaxhighlight>
|}

A static method receives neither <code>self</code> nor <code>cls</code> automatically.

== 14. Class methods ==

Python also provides class methods.

A class method receives the class itself as its first argument, conventionally called <code>cls</code>.

A common use is defining alternative constructors.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Point {
public:
    Point(double x, double y)
        : x(x), y(y)
    {
    }

    static Point origin()
    {
        return Point(0.0, 0.0);
    }

private:
    double x;
    double y;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    @classmethod
    def origin(cls):
        return cls(0.0, 0.0)
</syntaxhighlight>
|}

Usage:

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
Point p = Point::origin();
</syntaxhighlight>
|
<syntaxhighlight lang="python">
p = Point.origin()
</syntaxhighlight>
|}

Using <code>cls</code> rather than the explicit class name makes the method behave correctly when inherited by subclasses.

== 15. Instance method vs class method vs static method ==

{| class="wikitable" style="width:100%;"
! Method type
! First automatic argument
! Typical purpose
|-
| instance method
| <code>self</code>
| operate on an object
|-
| class method
| <code>cls</code>
| operate on the class / alternative constructors
|-
| static method
| none
| utility logically associated with the class
|}

Example:

<syntaxhighlight lang="python">
class Example:
    def instance_method(self):
        ...

    @classmethod
    def class_method(cls):
        ...

    @staticmethod
    def static_method():
        ...
</syntaxhighlight>

== 16. Inheritance ==

Inheritance is declared by placing the base class in parentheses.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Animal {
public:
    void eat()
    {
        std::cout << "Eating\n";
    }
};

class Dog : public Animal {
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Animal:
    def eat(self):
        print("Eating")


class Dog(Animal):
    pass
</syntaxhighlight>
|}

The subclass inherits members from the base class.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
Dog dog;
dog.eat();
</syntaxhighlight>
|
<syntaxhighlight lang="python">
dog = Dog()
dog.eat()
</syntaxhighlight>
|}

== 17. Calling the base-class constructor ==

C++ usually invokes a base-class constructor through the initializer list.

Python commonly uses <code>super()</code>.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Person {
public:
    Person(std::string name)
        : name(name)
    {
    }

protected:
    std::string name;
};

class Student : public Person {
public:
    Student(
        std::string name,
        int year
    )
        : Person(name),
          year(year)
    {
    }

private:
    int year;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Person:
    def __init__(self, name):
        self.name = name


class Student(Person):
    def __init__(self, name, year):
        super().__init__(name)
        self.year = year
</syntaxhighlight>
|}

== 18. Method overriding ==

A subclass can provide its own implementation of an inherited method.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Animal {
public:
    virtual void speak() const
    {
        std::cout << "Animal\n";
    }
};

class Dog : public Animal {
public:
    void speak() const override
    {
        std::cout << "Woof\n";
    }
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Animal:
    def speak(self):
        print("Animal")


class Dog(Animal):
    def speak(self):
        print("Woof")
</syntaxhighlight>
|}

Python does not require <code>virtual</code> or <code>override</code> keywords.

Method lookup is dynamic.

== 19. Polymorphism ==

The same interface can be used with objects of different classes.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
void makeSpeak(const Animal& animal)
{
    animal.speak();
}

Dog dog;
makeSpeak(dog);
</syntaxhighlight>
|
<syntaxhighlight lang="python">
def make_speak(animal):
    animal.speak()


dog = Dog()
make_speak(dog)
</syntaxhighlight>
|}

In Python, the object does not necessarily need to inherit from a particular base class.

== 20. Duck typing ==

Python often relies on '''duck typing'''.

If an object provides the operations that are required, its exact class may not matter.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++ — inheritance-oriented
! style="width:50%;" | Python — duck typing
|-
|
<syntaxhighlight lang="cpp">
class Speaker {
public:
    virtual void speak() const = 0;
};

void makeSpeak(const Speaker& s)
{
    s.speak();
}
</syntaxhighlight>
|
<syntaxhighlight lang="python">
def make_speak(obj):
    obj.speak()
</syntaxhighlight>
|}

For example:

<syntaxhighlight lang="python">
class Dog:
    def speak(self):
        print("Woof")


class Robot:
    def speak(self):
        print("Beep")


make_speak(Dog())
make_speak(Robot())
</syntaxhighlight>

<code>Dog</code> and <code>Robot</code> do not need a common Python base class for this function to work.

== 21. isinstance() ==

When an explicit runtime type check is actually required, Python provides <code>isinstance()</code>.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
Animal* animal = ...;

if (dynamic_cast<Dog*>(animal) != nullptr) {
    // It is a Dog.
}
</syntaxhighlight>
|
<syntaxhighlight lang="python">
if isinstance(animal, Dog):
    # It is a Dog.
    ...
</syntaxhighlight>
|}

However, frequent explicit type checks can indicate that polymorphism or another design should be used instead.

== 22. Composition ==

Composition means constructing a class from other objects rather than inheriting behavior.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Engine {
public:
    void start()
    {
        std::cout << "Engine started\n";
    }
};

class Car {
public:
    void start()
    {
        engine.start();
    }

private:
    Engine engine;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Engine:
    def start(self):
        print("Engine started")


class Car:
    def __init__(self):
        self.engine = Engine()

    def start(self):
        self.engine.start()
</syntaxhighlight>
|}

Composition is often preferable when the relationship is:

<syntaxhighlight lang="text">
has-a
</syntaxhighlight>

rather than:

<syntaxhighlight lang="text">
is-a
</syntaxhighlight>

== 23. Dataclasses ==

Many classes exist primarily to store data.

In C++, such classes or structures often require explicit constructors and comparison code.

Python provides <code>@dataclass</code>.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
struct Student {
    std::string name;
    int age;

    Student(
        std::string name,
        int age
    )
        : name(name),
          age(age)
    {
    }
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
from dataclasses import dataclass


@dataclass
class Student:
    name: str
    age: int
</syntaxhighlight>
|}

Creation is the same as for a normal class:

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
Student s("Alice", 21);
</syntaxhighlight>
|
<syntaxhighlight lang="python">
s = Student("Alice", 21)
</syntaxhighlight>
|}

The dataclass automatically generates useful methods such as <code>__init__()</code> and <code>__repr__()</code>.

== 24. Dataclass equality ==

Dataclasses also provide value-based equality by default.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
struct Point {
    int x;
    int y;

    bool operator==(const Point& other) const
    {
        return x == other.x &&
               y == other.y;
    }
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
from dataclasses import dataclass


@dataclass
class Point:
    x: int
    y: int
</syntaxhighlight>
|}

Now:

<syntaxhighlight lang="python">
a = Point(1, 2)
b = Point(1, 2)

print(a == b)  # True
</syntaxhighlight>

== 25. Special methods ==

Python classes can implement special methods, often called '''dunder methods''' because their names begin and end with two underscores.

They allow user-defined objects to participate in normal Python syntax.

Examples include:

{| class="wikitable" style="width:100%;"
! Python method
! Purpose
|-
| <code>__init__</code>
| initialize an object
|-
| <code>__str__</code>
| user-friendly string representation
|-
| <code>__repr__</code>
| developer-oriented representation
|-
| <code>__eq__</code>
| equality comparison
|-
| <code>__len__</code>
| support <code>len(obj)</code>
|-
| <code>__iter__</code>
| allow iteration
|-
| <code>__contains__</code>
| support <code>x in obj</code>
|}

== 26. __str__() ==

C++ commonly overloads <code>operator&lt;&lt;</code> for printable objects.

Python commonly implements <code>__str__()</code>.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Point {
public:
    Point(int x, int y)
        : x(x), y(y)
    {
    }

    friend std::ostream& operator<<(
        std::ostream& os,
        const Point& p
    )
    {
        return os
            << "("
            << p.x
            << ", "
            << p.y
            << ")";
    }

private:
    int x;
    int y;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"({self.x}, {self.y})"
</syntaxhighlight>
|}

Usage:

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
Point p(2, 3);

std::cout << p;
</syntaxhighlight>
|
<syntaxhighlight lang="python">
p = Point(2, 3)

print(p)
</syntaxhighlight>
|}

== 27. __repr__() ==

<code>__repr__()</code> should normally return a representation useful to a programmer.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
// No exact language-level equivalent.
// Usually implemented through
// debug output or operator<<.
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        return (
            f"Point(x={self.x}, "
            f"y={self.y})"
        )
</syntaxhighlight>
|}

Example:

<syntaxhighlight lang="python">
p = Point(2, 3)

print(repr(p))
</syntaxhighlight>

Output:

<syntaxhighlight lang="text">
Point(x=2, y=3)
</syntaxhighlight>

== 28. __eq__() ==

Python uses <code>__eq__()</code> to define the behavior of <code>==</code>.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Point {
public:
    bool operator==(const Point& other) const
    {
        return x == other.x &&
               y == other.y;
    }

private:
    int x;
    int y;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __eq__(self, other):
        if not isinstance(other, Point):
            return NotImplemented

        return (
            self.x == other.x
            and self.y == other.y
        )
</syntaxhighlight>
|}

In many simple data-holding classes, using <code>@dataclass</code> avoids writing this manually.

== 29. __len__() ==

A custom class can define what <code>len(obj)</code> means.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Course {
public:
    std::size_t size() const
    {
        return students.size();
    }

private:
    std::vector<std::string> students;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Course:
    def __init__(self):
        self.students = []

    def __len__(self):
        return len(self.students)
</syntaxhighlight>
|}

Usage:

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
std::cout << course.size();
</syntaxhighlight>
|
<syntaxhighlight lang="python">
print(len(course))
</syntaxhighlight>
|}

== 30. __iter__() ==

Implementing <code>__iter__()</code> allows an object to be used directly in a <code>for</code> loop.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Course {
public:
    auto begin()
    {
        return students.begin();
    }

    auto end()
    {
        return students.end();
    }

private:
    std::vector<std::string> students;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Course:
    def __init__(self):
        self.students = []

    def __iter__(self):
        return iter(self.students)
</syntaxhighlight>
|}

Now the class can be used naturally:

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
for (const auto& student : course) {
    std::cout << student << "\n";
}
</syntaxhighlight>
|
<syntaxhighlight lang="python">
for student in course:
    print(student)
</syntaxhighlight>
|}

== 31. Operator overloading ==

Python maps operators to special methods.

{| class="wikitable" style="width:100%;"
! Operation
! C++
! Python
|-
| addition
| <code>operator+</code>
| <code>__add__</code>
|-
| subtraction
| <code>operator-</code>
| <code>__sub__</code>
|-
| multiplication
| <code>operator*</code>
| <code>__mul__</code>
|-
| equality
| <code>operator==</code>
| <code>__eq__</code>
|-
| less than
| <code>operator&lt;</code>
| <code>__lt__</code>
|}

Example:

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Vector2D {
public:
    Vector2D(double x, double y)
        : x(x), y(y)
    {
    }

    Vector2D operator+(
        const Vector2D& other
    ) const
    {
        return Vector2D(
            x + other.x,
            y + other.y
        );
    }

private:
    double x;
    double y;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Vector2D:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector2D(
            self.x + other.x,
            self.y + other.y,
        )
</syntaxhighlight>
|}

Usage:

<syntaxhighlight lang="python">
a = Vector2D(1, 2)
b = Vector2D(3, 4)

c = a + b
</syntaxhighlight>

== 32. Attributes can be added dynamically ==

Python objects are usually more dynamic than C++ objects.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Student {
public:
    std::string name;
};

Student s;

// Not allowed unless "grade"
// was declared in Student.
// s.grade = 10;
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Student:
    pass


s = Student()

s.name = "Alice"
s.grade = 10
</syntaxhighlight>
|}

Although Python permits this, creating expected instance attributes in <code>__init__()</code> is generally clearer.

== 33. Type hints in classes ==

Python allows type hints for attributes and methods.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Student {
public:
    Student(
        std::string name,
        int year
    )
        : name(name),
          year(year)
    {
    }

    std::string description() const
    {
        return name;
    }

private:
    std::string name;
    int year;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Student:
    def __init__(
        self,
        name: str,
        year: int,
    ) -> None:
        self.name: str = name
        self.year: int = year

    def description(self) -> str:
        return self.name
</syntaxhighlight>
|}

Type hints improve readability and allow static analysis tools to detect some errors before runtime.

== 34. Example — Course and Student classes ==

Consider a small system containing students and a course.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
#include <string>
#include <vector>

class Student {
public:
    Student(
        std::string name,
        double grade
    )
        : name(name),
          grade(grade)
    {
    }

    std::string getName() const
    {
        return name;
    }

    double getGrade() const
    {
        return grade;
    }

private:
    std::string name;
    double grade;
};

class Course {
public:
    void addStudent(const Student& student)
    {
        students.push_back(student);
    }

    double average() const
    {
        double sum = 0.0;

        for (const auto& student : students) {
            sum += student.getGrade();
        }

        return sum / students.size();
    }

private:
    std::vector<Student> students;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
from dataclasses import dataclass


@dataclass
class Student:
    name: str
    grade: float


class Course:
    def __init__(self):
        self.students = []

    def add_student(self, student):
        self.students.append(student)

    def average(self):
        total = sum(
            student.grade
            for student in self.students
        )

        return total / len(self.students)
</syntaxhighlight>
|}

The Python implementation uses:

* a dataclass for the simple data-holding <code>Student</code> class;
* direct attribute access;
* a normal class for <code>Course</code>;
* a generator expression for calculating the total.

== 35. Example — Adding Python protocol behavior ==

We can make the <code>Course</code> class behave more naturally in Python.

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | Conventional explicit API
! style="width:50%;" | Pythonic API
|-
|
<syntaxhighlight lang="python">
class Course:
    def __init__(self):
        self.students = []

    def get_student_count(self):
        return len(self.students)

    def get_students(self):
        return self.students
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class Course:
    def __init__(self):
        self.students = []

    def __len__(self):
        return len(self.students)

    def __iter__(self):
        return iter(self.students)
</syntaxhighlight>
|}

The second version allows:

<syntaxhighlight lang="python">
print(len(course))

for student in course:
    print(student)
</syntaxhighlight>

This is a recurring Python design principle:

<blockquote>
Prefer implementing the protocol expected by Python instead of inventing unnecessary custom method names.
</blockquote>

== 36. C++ habits to reconsider ==

{| class="wikitable" style="width:100%;"
! C++ habit
! Typical Python approach
|-
| create getters and setters for every field
| use public attributes unless behavior or validation is required
|-
| enforce access through <code>private</code>
| use naming conventions and properties
|-
| create a class for every small data structure
| consider <code>@dataclass</code>
|-
| require a common base class for polymorphism
| consider duck typing
|-
| create methods such as <code>getSize()</code>
| implement <code>__len__()</code> when appropriate
|-
| create methods such as <code>toString()</code>
| implement <code>__str__()</code>
|-
| create explicit collection access methods
| consider <code>__iter__()</code>
|-
| use inheritance to reuse implementation
| consider composition
|}

== 37. Exercise 1 — Rectangle ==

Implement a <code>Rectangle</code> class.

The equivalent C++ design is:

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++
! style="width:50%;" | Python
|-
|
<syntaxhighlight lang="cpp">
class Rectangle {
public:
    Rectangle(double width, double height)
        : width(width),
          height(height)
    {
    }

    double area() const
    {
        return width * height;
    }

    double perimeter() const
    {
        return 2 * (width + height);
    }

private:
    double width;
    double height;
};
</syntaxhighlight>
|
'''Your implementation:'''

<syntaxhighlight lang="python">
# TODO
</syntaxhighlight>
|}

Requirements:

* store width and height;
* implement <code>area()</code>;
* implement <code>perimeter()</code>;
* implement <code>__str__()</code>;
* reject negative dimensions using properties.

== 38. Exercise 2 — Bank account ==

Implement a <code>BankAccount</code> class.

The class should contain:

* owner name;
* account number;
* current balance.

Implement:

<syntaxhighlight lang="text">
deposit(amount)
withdraw(amount)
</syntaxhighlight>

Rules:

* deposits must be positive;
* withdrawals must be positive;
* a withdrawal cannot exceed the current balance;
* invalid operations should raise an exception;
* the balance should not be modified directly from outside the class.

Suggested interface:

{| class="wikitable" style="width:100%; table-layout:fixed;"
! style="width:50%;" | C++ idea
! style="width:50%;" | Python idea
|-
|
<syntaxhighlight lang="cpp">
class BankAccount {
public:
    void deposit(double amount);
    void withdraw(double amount);

    double getBalance() const;

private:
    double balance = 0.0;
};
</syntaxhighlight>
|
<syntaxhighlight lang="python">
class BankAccount:
    def deposit(self, amount):
        ...

    def withdraw(self, amount):
        ...

    @property
    def balance(self):
        ...
</syntaxhighlight>
|}

== 39. Exercise 3 — Inheritance ==

Create the following hierarchy:

<syntaxhighlight lang="text">
Shape
├── Rectangle
└── Circle
</syntaxhighlight>

Each shape must provide:

<syntaxhighlight lang="text">
area()
</syntaxhighlight>

Then write a function:

<syntaxhighlight lang="python">
def print_area(shape):
    ...
</syntaxhighlight>

that works with either a rectangle or a circle.

Compare the design mentally with the equivalent C++ solution based on a virtual function.

== 40. Exercise 4 — Composition ==

Create:

<syntaxhighlight lang="text">
Engine
Car
</syntaxhighlight>

The <code>Engine</code> class should provide:

<syntaxhighlight lang="text">
start()
stop()
</syntaxhighlight>

The <code>Car</code> class should '''contain''' an <code>Engine</code> object rather than inherit from <code>Engine</code>.

Implement:

<syntaxhighlight lang="python">
car.start()
car.stop()
</syntaxhighlight>

so that these methods delegate to the contained engine.

== 41. Exercise 5 — Dataclass ==

Create a <code>Student</code> dataclass containing:

* name;
* student ID;
* year;
* grade.

Then:

# create at least three students;
# place them in a list;
# print them;
# compare two students using <code>==</code>;
# determine the student with the highest grade.

Start from:

<syntaxhighlight lang="python">
from dataclasses import dataclass


@dataclass
class Student:
    # TODO
    ...
</syntaxhighlight>

== 42. Exercise 6 — Custom collection ==

Implement a <code>Course</code> class that stores <code>Student</code> objects.

The class should support:

<syntaxhighlight lang="python">
course.add(student)

len(course)

for student in course:
    ...

print(course)
</syntaxhighlight>

To achieve this, implement:

* <code>add()</code>;
* <code>__len__()</code>;
* <code>__iter__()</code>;
* <code>__str__()</code>.

== 43. Exercise 7 — Vector2D ==

Implement a two-dimensional vector class.

The following operations should be possible:

<syntaxhighlight lang="python">
a = Vector2D(1, 2)
b = Vector2D(3, 4)

c = a + b

print(c)
print(a == b)
</syntaxhighlight>

Implement:

* <code>__init__()</code>;
* <code>__add__()</code>;
* <code>__eq__()</code>;
* <code>__str__()</code>.

The equivalent C++ concepts are constructor definition and operator overloading.

== 44. Exercise 8 — Refactoring C++ style into Python style ==

Consider the following Python class:

<syntaxhighlight lang="python">
class Student:
    def __init__(self):
        self._name = ""
        self._grade = 0.0

    def get_name(self):
        return self._name

    def set_name(self, name):
        self._name = name

    def get_grade(self):
        return self._grade

    def set_grade(self, grade):
        self._grade = grade
</syntaxhighlight>

Refactor it into a more idiomatic Python design.

Questions to consider:

* Are explicit getters necessary?
* Are explicit setters necessary?
* Would a dataclass be appropriate?
* Is validation required?
* Which attributes should be public?

== 45. Summary ==

The main mappings introduced in this laboratory are:

{| class="wikitable" style="width:100%;"
! C++
! Python
|-
| constructor
| <code>__init__()</code>
|-
| <code>this</code>
| <code>self</code>
|-
| static data member
| class attribute
|-
| static member function
| <code>@staticmethod</code>
|-
| no direct equivalent
| <code>@classmethod</code>
|-
| getter / setter
| often direct attribute access or <code>@property</code>
|-
| <code>private</code>
| naming convention / name mangling
|-
| base-class constructor
| <code>super().__init__()</code>
|-
| virtual method
| normal dynamically dispatched method
|-
| value-oriented struct
| <code>@dataclass</code>
|-
| <code>operator&lt;&lt;</code>
| <code>__str__()</code>
|-
| <code>operator==</code>
| <code>__eq__()</code>
|-
| <code>size()</code>
| <code>__len__()</code>
|-
| <code>begin()</code> / <code>end()</code>
| <code>__iter__()</code>
|-
| operator overloading
| special methods such as <code>__add__()</code>
|}

The central idea of this laboratory is:

<blockquote>
Python supports object-oriented programming, but idiomatic Python does not attempt to reproduce C++ class design exactly. Use Python's object model, conventions and protocols rather than mechanically translating C++ patterns.
</blockquote>

== 46. Preparation for Lab 3 ==

Before the next laboratory:

# complete the exercises from this laboratory;
# review Python lists, dictionaries and comprehensions;
# be comfortable creating classes and methods;
# understand the difference between instance and class attributes;
# understand inheritance and composition;
# review exception handling from Lab 1.

In '''Lab 3''', the focus will move from individual classes to the structure of complete Python applications: modules, packages, files, exceptions, type hints and project organization.