Object-Oriented Programming - Exercises

OOP exercise with Python

Setup

Launching a VSCode service

• Connect to SSP Cloud
• Launch a Vscode-python service, then open it

Creating your directory structure

• Create 2 folders geometrie (exercises 1 and 2) and domino (exercise 3)
  • 💡 avoid using accents in your code, computers don’t like them very much

Important

Whenever you are asked to create a class, you should start by creating a file with the same name.

Help

Tip

You will find some suggested solutions on the introductory OOP course page.

Here are some simple code examples if you need inspiration:

• deux_roues.py : abstract parent class representing a two-wheeled vehicle
• trottinette.py : class representing a scooter (inherits from DeuxRoues)
• velo.py : class representing a bicycle (inherits from DeuxRoues)
• main.py : a sandbox file for testing

1 Exercise 1 - Points

Define a Point class to represent a point in the plane with x and y coordinates.

• Start by creating a point.py file in the geometrie folder
• In this file, create the Point class and its constructor __init__(self, x, y)

Implement the following methods:

• r(self) and t(self): returning the polar coordinates of the point
• __str__(self): to display the Point as text, e.g.: (1.0, 2.4)
• distance(self, autre_point) -> float: distance to another point
• __eq__(self, autre_point) -> bool: tells whether the 2 points are identical
• homothetie(self, k): applying a homothety centered at (0, 0) with ratio k to the point
• translation(self, dx, dy): applying a translation with vector (dx, dy) to the point
• rotation(self, a) (bonus): applying a rotation centered at (0, 0) with angle a to the point

Tip

To check that your methods are correct, you can add a main block at the end of your class. When you run this file, this is the code that will be executed.

point.py

class Point:

    # ...

if __name__ == "__main__":
    p1 = Point(1, 2)
    p2 = Point(1, 2)
    print(f"p1 : {p1}")
    print(f"Distance entre p1 et p2 : {p1.distance(p2)}")
    print(f"p1 est égal à p2 : {p1 == p2}")

2 Exercise 2 - Polygons

You will now use objects from the Point class to create more complex objects.

You will also use inheritance, i.e. reusable behaviors will be defined in the parent classes and specific behaviors in the child classes.

• Create a Polygone class composed of Point objects
  • We will assume that the segments do not intersect
• Add 2 abstract methods aire() and perimetre() to this class
  • these methods will be defined in the child classes
• Create the Segment, Triangle and Quadrilatere classes that inherit from the Polygone class
  • check the number of points each time
• Define the aire() and perimetre() methods in these 3 classes
• Create the Rectangle class that inherits from Quadrilatere
• Check for Rectangle that the 2 opposite sides have the same length and that there is a right angle

Here is the class diagram generated with Mermaid

classDiagram
    Point --o Polygon
    Polygon <|-- Segment : 2
    Polygon <|-- Triangle : 3
    Polygon <|-- Quadrilateral : 4
    Quadrilateral <|-- Rectangle
    class Point{
        +float x
        +float y
        +distance(other_point)
    }
    class Polygon{
        +list[Point] points_list
        +area()
        +perimeter()
    }
    class Quadrilateral{
        +area()
        +perimeter()
    }
    class Segment{
        +area()
        +perimeter()
    }
    class Triangle{
        +area()
        +perimeter()
    }

3 Exercise 3 - Domino

3.1 A Domino

Write a Domino class with:

• 2 integer attributes between 0 and 6: end_A and end_B
• __str__(): which displays the dots present on both ends
• flip(): which flips the domino (its A end becomes its B end and vice versa)
• accepts_after(other_domino): checks whether the B end of the current domino has the same value as the A end of the other domino

3.2 Game

Now we will try to code a domino game.

For simplicity:

• there will only be one player
• it is only possible to place a domino on one side, at the end of the domino row

Let’s start by generating all possible dominoes, i.e. all combinations from (0,0) to (6,6) without duplicates.

• Write a function that generates all dominoes and returns the list
• Write an display_dominoes() function that displays a list of dominoes
• Write a draw() function that randomly draws a domino from a list and removes it from that list
• Write a playable_dominoes(hand_dominoes, placed_dominoes) function that takes two lists of dominoes as arguments. The function returns the list of dominoes in hand that could be placed after the last domino in the placed_dominoes list.

Write a play() function that:

• generates the list of all dominoes
• randomly draws a first domino and places it in the placed_dominoes list
• randomly distributes 6 dominoes to the player
• displays the dominoes they can play
• if no domino can be played, offer them the possibility to draw
• asks which domino they want to play (for example by asking them to enter the number in the domino list, and quit to stop playing)
• adds the played domino to the placed_dominoes list and removes it from the hand_dominoes list

classDiagram
    class Domino{
        +int end_A
        +int end_B
        +flip()
        +accepts_after(other_domino)
    }

Correction

TipSuggested solution

Exercises 1 and 2

• point.py
• polygone.py
• segment.py
• triangle.py
• quadrilatere.py
• rectangle.py

An example of unit tests for the Point class:

• test_point.py

Exercise 3

• domino.py
• jeu.py