Mathieu Agopian : Objets ou fonctions

Avec des objets

J'ai opté pour un découpage « raisonnable » (on a fait une session avec un CellContext qui s'occupait de gérer les cellules voisines, au lieu de grouper ça directement dans l'objet Cell, mais je trouvais ça un brin trop over-engineered).

La logique est d'initialiser une fois pour toutes les cellules voisines pour chaque cellule, ce qui simplifie le comptage des voisines en vie.

WORLD = [  # False = dead cell, True = live cell
    [False, False, False, False, False],
    [False, True, False, True, False],
    [False, True, True, False, False],
    [False, False, True, True, False],
    [False, False, False, False, False],
]


class Cell:

    def __init__(self, alive=False):
        self.neighbours = []
        self.alive = alive

    def add_neighbour(self, cell):
        self.neighbours.append(cell)

    def get_num_live_neighbours(self):
        return len([cell for cell in self.neighbours if cell.alive])

    def mutate(self):
        live_neighbours = self.get_num_live_neighbours()
        survives = self.alive and live_neighbours in [2, 3]
        born = not self.alive and live_neighbours == 3
        self.next_state = born or survives
        return self.next_state

    def step(self):
        self.alive = self.next_state

    def __str__(self):
        return 'O' if self.alive else ' '


class World:

    neighbours_rel_pos = [  # relative position of all possible neighbours
        (-1, -1), (-1, 0), (-1, 1),  # upper row
        (0, -1), (0, 1),  # same row
        (1, -1), (1, 0), (1, 1)]  # lower row

    def __init__(self, board):
        self.board = [[Cell(alive) for alive in line]
                      for line in board]

        # initialize neighbours for all cells
        for x, line in enumerate(self.board):
            for y, cell in enumerate(line):
                for neigh_pos_x, neigh_pos_y in self.neighbours_rel_pos:
                    pos_x = x + neigh_pos_x
                    pos_y = y + neigh_pos_y
                    if (pos_x >= 0 and pos_x < len(self.board) and
                            pos_y >= 0 and pos_y < len(self.board[0])):
                        cell.add_neighbour(self.board[pos_x][pos_y])

    def step(self):
        for line in self.board:  # compute next state
            for cell in line:
                cell.mutate()
        for line in self.board:  # apply
            for cell in line:
                cell.step()

    def __str__(self):
        return "\n".join("".join(str(cell) for cell in line)
                         for line in self.board)

67 lignes, 2 objets, 9 méthodes.

Avec des fonctions

WORLD = [  # False = dead cell, True = live cell
    [False, False, False, False, False],
    [False, True, False, True, False],
    [False, True, True, False, False],
    [False, False, True, True, False],
    [False, False, False, False, False],
]


def evolve_world(world):
    new_world = [line[:] for line in world]  # copy the current world
    for x, line in enumerate(new_world):
        for y, cell in enumerate(line):
            new_world[x][y] = evolve_cell(new_world[x][y],
                                          num_alive_neighbours(world, x, y))
    return new_world


def evolve_cell(cell_alive, num_neighbours):
    return ((cell_alive and num_neighbours in [2, 3]) or
            (not cell_alive and num_neighbours == 3))


def num_alive_neighbours(world, x, y):
    neighbours_rel_pos = [  # relative position of all possible neighbours
        (-1, -1), (-1, 0), (-1, 1),  # upper row
        (0, -1), (0, 1),  # same row
        (1, -1), (1, 0), (1, 1)]  # lower row

    count = 0
    for neigh_pos_x, neigh_pos_y in neighbours_rel_pos:
        pos_x = x + neigh_pos_x
        pos_y = y + neigh_pos_y
        if (pos_x >= 0 and pos_x < len(world) and
                pos_y >= 0 and pos_y < len(world[0]) and
                world[pos_x][pos_y]):
            count += 1
    return count


def world_tostring(world):
    return "\n".join("".join("O" if alive else " " for alive in line)
                     for line in world)

43 lignes, 4 fonctions.

Avec des objets

En POO, on scinde la donnée d'entrée (base de données, fichiers, flux de données...) pour la répartir dans différents objets. Dans notre exemple, un objet World qui stocke l'ensemble des cellules, et un objet Cell qui stocke son état (en vie ou morte) et l'ensemble de ses voisines.

• + Représentation mentale aisée des différentes entitées
• + Répartition des responsabilités
• - Verbosité
• - Difficulté pour les tests : il faut gérer les fixtures

Avec des fonctions

En fonctionnel, on traite directement la donnée d'entrée par des étapes successives et différentes fonctions que l'on compose.

• + Concision
• + Moins de code à maintenir, moins de code à lire et comprendre
• + Facilité pour les tests
• - Duplication de la donnée (nouveau monde à chaque itération)
• - Recalcul des voisins à chaque itération

Avec des objets

La réutilisation du code dans la POO se fait principalement par l'héritage d'objets.

Imaginons que nous ayons demain un monde différent, qui au lieu d'être représenté par un tableau de cellules carrées, soit un amas de cellules hexagonales. On pourrait alors avoir un objet HexagonalWorld qui hériterait de World et redéfinirait les méthodes __init__ et __str__.

Le reste du code resterait le même, et serait donc réutilisé.

On peut encore imaginer des cellules plus ou moins résistantes qui, en redéfinissant mutate auraient des règles différentes de vie ou de mort.

Avec des fonctions

La réutilisation du code dans la programmation fonctionnelle se fait par la composition de fonctions.

On aurait pu imaginer partir d'un format différent pour le monde, sous la forme d'une suite de 0 et de 1.

On aurait alors tout d'abord transformé chaque 0 ou 1 en booléen puis découpé cette suite en lignes d'une longueur donnée, composant deux fonctions :

data = "001001100"
to_bool(data) == [False, False, True, False, False, True, True, False, False]
to_grid(to_bool(data)) == [
    [False, False, True],
    [False, False, True],
    [True, False, False]]

Si ce n'est pas d'une série de 0 et de 1 qu'on part, mais de X et de O, on change la fonction to_bool, la fonction to_grid reste identique.