Aller au contenu principal
Physique, Chimie et Informatique > Terminales Spé. NSI

Programmation objet

Au programme

Contenus Capacités attendues Commentaires
Vocabulaire de la programmation objet : classes, attributs, méthodes, objets. - Écrire la définition d’une classe.
- Accéder aux attributs et méthodes d’une classe.
On n’aborde pas ici tous les aspects de la programmation objet comme le polymorphisme et l’héritage.

Documents

23 sept. 2020

Sous-sections de Programmation objet

Physique, Chimie et Informatique > Terminales Spé. NSI > Programmation objet

Programmation Objet

Programmation orientée objet

À retenir

Un objet est une instance d’une classe.

L’un des objectifs principaux de la notion d’objet est d’organiser des programmes complexes grâce aux notions :

  • d’encapsulation ;
  • d’abstraction ;
  • d’héritage ;
  • de polymorphisme ;

Remarque : Seules les deux premières notions apparaissent dans le programme de NSI.

Encapsulation

Le principe de l’encapsulation est de regrouper dans le même objet, les données (attributs) et les traitements (méthodes) qui lui sont spécifiques. Ainsi un objet est défini par ses attributs et ses méthodes.

Les objets partagent tous les mêmes méthodes mais les attributs leurs sont propres.

Abstraction

L’intérêt de la POO est qu’elle permet de créer des objets possédant un certain degré d’abstraction. Ce processus d’abstraction consiste à identifier des caractéristiques et des mécanismes communs pour un ensemble d’éléments.

Attributs
Ce sont les données de l’objets, ses caractéristiques.
Méthodes
Ce sont les comportements de l’objet.
Héritage

Le concept d’héritage permet de créer des sous-classes plus spécialisées à partir de classes plus générales (appelées super-classe).

  • La super-classe (classe mère) déclare des méthodes et des attributs communs.
  • La sous-classe hérite des attributs, des méthodes et du type de la super-classe et peut les redéfinir (cf. polymorphisme).
Polymorphisme

Le polymorphisme est la faculté pour une méthode portant le même nom mais appartenant à des classes distinctes héritées d’effectuer un travail différent. Cette propriété est acquise par la technique de la surcharge.

Compte bancaire

Info

Toute cette partie doit être réalisée en utilisant le logiciel Python Tutor. Sélectionner Start visualizing your code now puis Live Programming mode.

Dans ce premier exemple, on considère une classe qui modélise un compte bancaire.

Une classe est un nouveau type et un objet est une instance de classe

  1. Taper et exécuter le code suivant :
class Compte:
    """
    Modélisation d'un compte bancaire.
    """

    pass
Info
  • Un nom de classe commence toujours (c’est une convention) par une lettre capitale ;
  • pass est l’instruction Python qui indique de ne rien faire.

Quelles actions a déclenché le code précédent ?

Réponse
  • Création d’un objet Classe Compte ;
  • Création d’une variable Compte dans l’espace de nom global. Cette variable référence l’objet Classe Compte

  1. À la suite, taper et exécuter le code suivant :
compte_1 = Compte()

Quelle action a déclenché le code précédent ?

Réponse
  • Création d’un objet (ou instance) de la classe Compte ;
  • Création d’une variable compte_1 dans l’espace de nom global. Cette variable référence l’objet.

  1. Afin d’en découvrir davantage sur compte_1, taper et exécuter l’instruction suivante :
print(compte_1)

Que nous apprend l’affichage à l’écran ?

Réponse
<__main__.Compte object at 0x7f7cc89bec88>

compte_1 appartient à l’espace de nom global et référence un objet de type Compte situé à l’adresse 0x7f7cc89bec88.

  1. « Définir une classe est équivalent à définir un nouveau type. » Quelle instruction Python pourrait démontrer cette affirmation ?
    Réponse
    print(type(compte_1))

Un objet possède des attributs dont les valeurs lui sont propres

  1. Un compte bancaire possède généralement un propriétaire et un solde. Taper et exécuter les lignes de code suivantes :
compte_1.proprietaire = "Pascal"
compte_1.solde = 1000

Les attributs (ou variable) proprietaire et solde appartiennent-ils à l’espace de nom global ?

Réponse
À retenir

Les attributs sont des variables locales à l’objet.

  1. Taper et exécuter les instructions qui permettent de créer un objet compte_2 dont le propriétaire se nomme « Natacha » et dont le solde est de 2000.

    Réponse
    compte_2 = Compte()
    compte_2.proprietaire = "Natacha"
    compte_2.solde = 2000

  2. Les objets compte_1 et compte_2 partagent-ils les valeurs des attributs ?

    Réponse

    Les attributs sont des variables locales à l’objet.

    À retenir

    Deux instances d’une même classe ne partagent pas leurs attributs.

Un objet possède un comportement

  1. Modifier le code de définition de la classe de façon à ce qu’il soit :
class Compte:
    """
    Modélisation d'un compte bancaire.
    """

    def retrait(self, valeur: float) -> None:
        """
        Retire valeur au solde.
        """
        self.solde = self.solde - valeur

La fonction retrait est appelée méthode. Quelle est sa particularité ?

Réponse

La fonction retrait est locale à la classe ; c’est la raison pour laquelle on parle de méthode.

  1. La méthode retrait est-elle locale à chaque objet ?

    Réponse
    À retenir

    Les objets instances d’une même classe partagent les méthodes.

  2. Natacha vient de retirer 50. Le code qui permet de prendre en compte ce retrait dans le programme est

compte_2.retrait(50)
  • Observer l’effet de l’instruction.
  • N’y a-t-il rien de surprenant dans l’appel de la méthode retrait ?
Réponse

La définition de la méthode retrait fait apparaître deux paramètres : self et valeur alors que lors de l’appel de la fonction on ne fournit qu’un seul argument qui semble être valeur.

  1. À quoi peut bien servir le paramètre self dans la définition d’une méthode ?

    Réponse
    Info

    Les méthodes étant partagées par les différentes instances (objets) d’une classe, elle ne peuvent à priori pas savoir sur quel objet elle doivent agir.
    L’information sur cet objet est donc passée automatiquement par Python à la méthode. Pour être plus clair, l’instruction

    compte_2.retrait(50)

    est équivalente à

    Compte.retrait(compte_2, 50)
    À retenir

    Lorsqu’on définit une méthode, le premier paramètre doit toujours être nommé self (c’est une convention). Il représente l’objet sur lequel la méthode doit agir.

  2. Créer l’objet compte_3 et lui retrirer le montant 100. Quel est le problème ?

    Réponse
    compte_3 = Compte()
    compte_3.retrait(100)

    On obtient l’erreur suivante :

    AttributeError: 'Compte' object has no attribute 'solde'

    C’est tout à fait normal car l’objet compte_3 ne possède par d’attribut solde.

Les attributs d’un objet doivent être initialisés à la création de cet objet

  1. Modifier le code de la classe Compte :
class Compte:
    """
    Modélisation d'un compte bancaire.
    """

    def __init__(self, proprietaire: str = "", solde: float = 0) -> None:
        self.proprietaire = proprietaire
        self.solde = solde

    def retrait(self, valeur: float) -> None:
        """
        Retire valeur au solde.
        """
        self.solde = self.solde - valeur
  • Est-ce que l’erreur apparue à la question 12. est toujours présente ?
  1. Afin de bien comprendre le rôle de la méthode __init__, créer le compte compte_4. À quoi sert cette méthode ?
    Réponse

    La méthode permet d’initialiser l’objet : ses attributs sont automatiquement créés, des valeurs par défaut peuvent même leur être affectées.

Toutes les variables ne sont pas des attributs

  1. Essayer d’imaginer comment déterminer simplement le nombre de comptes créés.

    Réponse

    L’idéal serait qu’un compteur compte soit incrémenté chaque fois qu’un compte est créé.

  2. Modifier le code de la classe Compte :

class Compte:
    """
    Modélisation d'un compte bancaire.
    """

    nbre_comptes = 0

    def __init__(self, proprietaire: str = "", solde: float = 0) -> None:
        self.proprietaire = proprietaire
        self.solde = solde

    def retrait(self, valeur: float) -> None:
        """
        Retire valeur au solde.
        """
        self.solde = self.solde - valeur

La variable nbre_comptes est-elle locale aux objets ? Est-elle locale à la classe ?

Réponse

La variable nbre_comptes est locale à la classe : c’est une variable de classe.

À retenir

Les variables de classe sont partagées par tous les objets.

  1. Modifier le code de la classe Compte :
class Compte:
    """
    Modélisation d'un compte bancaire.
    """

    nbre_comptes = 0

    def __init__(self, proprietaire: str = "", solde: float = 0) -> None:
        Compte.nbre_comptes = Compte.nbre_comptes + 1
        self.proprietaire = proprietaire
        self.solde = solde

    def retrait(self, valeur: float) -> None:
        """
        Retire valeur au solde.
        """
        self.solde = self.solde - valeur
  • Comment manipule-t-on une variable de classe ?
Réponse
À retenir

Pour manipuler une variable de classe, il faut précéder son nom du nom de la classe.

Physique, Chimie et Informatique > Terminales Spé. NSI > Programmation objet

Simulation du fonctionnement d'une banque

L’objectif de ce document est de simuler (sommairement bien sûr) le fonctionnement d’une banque. Le programme doit permettre :

  • La création d’une banque ;
  • La création de comptes bancaires ;
  • La création de personnes propriétaires de ces comptes bancaires.

Une correction se trouve à cette adresse : https://repl.it/@dlatreyte/banque

Classe Personne

Dans un module nommé personne, créer la classe Personne dont la spécification est la suivante :

class Personne:
    """
    Modélisation d'une personne.

    Attributs
    ---------
    - nom : str
        Renseigné à la création de l'objet
    - Prenom : str
        Renseigné à la création de l'objet
    - email : str
        Email. Initialisé à ""
    - telephone : str
        Numéro de téléphone. Initialisé à ""
    - date_naissance : str
        Chaîne de caractères au format jour/mois/année (4 chiffres). Initialisé à ""
    - jour_naissance : int
        Déterminé à partir de la date de naissance. Initialisée à -1
    - mois_naissance : int
        Déterminé à partir de la date de naissance. Initialisée à -1
    - annee_naissance : int
        Déterminé à partir de la date de naissance. Initialisée à -1
    """

Les spécifications des méthodes sont les suivantes :

def __init__(self, nom: str, prenom: str) -> None:
    """
    Initialisation des attributs.
    """
def modifier_nom(self, nom: str) -> None:
    """
    Permet de modifier le nom de la personne.
    """
def obtenir_nom(self) -> str:
    """
    Retourne le nom de la personne.
    """
def modifier_prenom(self, prenom: str) -> None:
    """
    Permet de modifier le prénom de la personne.
    """
def obtenir_prenom(self) -> str:
    """
    Retourne le prénom de la personne.
    """
def obtenir_email(self) -> str:
    """
    Retourne l'email de la personne.
    """
def renseigner_email(self, email: str) -> None:
    """
    Renseigne l'attribut email de la personne.
    """
def obtenir_telephone(self) -> str:
    """
    Retourne le numéro de téléphone de la personne.
    """
def renseigner_telephone(self, telephone: str) -> None:
    """
    Renseigne l'attribut telephone de la personne.
    """
def renseigner_date_naissance(self, date: str) -> None:
    """
    Récupère la date de naissance sous la forme jour/mois/année.
    Renseigne l'attribut date_naissance et, après un traitement, les attributs
    jour_naissance, mois_naissance, annee_naissance.

    Lève une exception de type ValueError si l'année ne possède pas le bon format.
    """
def obtenir_date_naissance(self) -> str:
    """
    Retourne la date de naissance.
    """
def obtenir_age(self, annee_en_cours: int) -> int:
    """
    Retourne l'age de la personne à partir de l'année en cours.

    Lève une exception de type Exception si la date de naissance n'a pas été renseignée au préalable.
    """

La méthode infos suivante doit aussi faire parti de cette classe :

def infos(self) -> str:
    """
    Retourne toutes les informations relatives à la personne.
    """

    chaine = """
        Prénom : {}
        Nom : {}
        Date de naissance : {}
        Email : {}
        Téléphone : {}
        """.format(
        self.obtenir_prenom(),
        self.obtenir_nom(),
        self.obtenir_date_naissance(),
        self.obtenir_email(),
        self.obtenir_telephone(),
    )

    return chaine
Avertissement

Tester la classe en instanciant au moins un objet de type Personne et en utilisant toutes les méthodes.

Classe Compte_bancaire

Dans un module nommé compte_bancaire créer la classe Compte_bancaire dont la spécification est la suivante :

class Compte_bancaire():
    """
    Définition d'un compte bancaire.

    Attributs
    ---------
    - proprietaire : Personne
        Personne propriétaire du compte. Initialisé à la création de l'objet.
    - identifiant : int
        Identifiant unique du compte. Initialisé à la création de l'objet par un calcul réalisé par une méthode statique.
    - solde : float
        Solde du compte. Initialisé à la création de l'objet.

Les spécifications des méthodes sont les suivantes :

Avertissement

Ne pas oublier d’importer la classe Personne du module personne au début du fichier.

def __init__(self, proprietaire: Personne, montant_initial: float) -> None:
    """
    Initialisation des attributs.
    """
@staticmethod
def determine_id(proprietaire: Personne) -> int:
    """
    Détermine l'identifiant du compte aléatoirement à partir du
    nom et du prénom du propriétaire.

    Méthode statique
    """
def obtenir_solde(self) -> float:
    """
    Retourne le solde du compte.
    """
def depot(self, montant: float) -> None:
    """
    Ajoute montant au solde
    """
def retrait(self, montant: float) -> None:
    """
    Retire le montant montant du solde à la condition qu'il y ait suffisamment d'argent.
    Une exception de type ValueError est levée si le montant est trop important
    """

La méthode infos suivante fait aussi partie de la classe :

def infos(self) -> str:
    """
    Informations sur le compte.
    """
    chaine = """
    Compte numéro : {}
    Solde : {}
    """.format(self.identifiant, self.solde)

    chaine = chaine + self.proprietaire.infos()

    return chaine
Avertissement

Tester la classe en instanciant au moins un objet de type Compte_bancaire et en utilisant toutes les méthodes.

Classe Banque

Cette classe est de loin la moins développée du document, vous pourrez ajouter des méthodes selon vos idées.

Dans un module nommé banque, créer la classe Banque dont la spécification est la suivante :

class Banque:
    """
    Modélisation d'une banque.

    Attributs
    ---------
    - nom : str
        Nom de la banque. Initialisé lors de la création de l'objet.
    - comptes : Liste[Compte_bancaire]
        Liste des comptes bancaires au sein de la banque.
    """
Avertissement
  • Ne pas oublier d’importer la classe Personne du module personne au début du fichier.
  • Ne pas oublier d’importer la classe Compte_bancaire du module compte_bancaire au début du fichier.

Les spécifications des méthodes sont les suivantes :

def __init__(self, nom: str) -> None:
    """
    Initialisation de l'objet
    """

Incorporer les méthodes suivantes dans la classe :

def creation_compte(self) -> None:
    """
    Prend en charge l'ouverture d'un compte au sein de la banque.
    """
    print("Procédure de création du compte :")
    print("---------------------------------")

    nom = input("Nom du propriétaire du compte : ")
    prenom = input("Prenom du propriétaire du compte : ")
    montant_initial = float(input("Montant du dépôt initial : "))

    p = Personne(nom, prenom)
    c = Compte_bancaire(p, montant_initial)

    self.comptes.append(c)


def infos(self) -> str:
    """
    Informations sur la banque
    """
    chaine = """
    -----------
    """

    for compte in self.comptes:
        chaine = chaine + compte.infos()
        chaine = """
        -----------

        """

    return chaine

Programme principal

Dans le fichier nommé main, instancier un objet de type Banque et créer quelques comptes bancaires.

Physique, Chimie et Informatique > Terminales Spé. NSI > Programmation objet

Méthodes spéciales en Python

Définit une classe nommée Fraction pour représenter les nombres rationnels. Cette classe doit posséder deux attributs num et denom, de type entier, qui représentent respectivement le numérateur et le dénominateur du nombre rationnel.
On demande que le dénominateur soit un entier positif.

Un corrigé de cette activité se trouve à cette adresse : https://repl.it/@dlatreyte/fraction

  1. Écrire le constructeur de cette classe. Une exception de type ValueError doit être levée si le dénominateur n’est pas un nombre entier positif.

  2. Ajouter une méthode __str__ qui renvoie une chaîne de caractères de la forme "12 / 7", ou simplement "12" lorsque le dénominateur vaut 1.

  3. Ajouter les méthodes __add__ et __mul__ qui reçoivent une deuxième fraction et qui retournent un nouvel objet de type Fraction, représentant respectivement la somme et le produit de deux fractions.

  4. Ajouter des méthodes __eq__ et __lt__ qui reçoivent une deuxième fraction et qui retournent True si la première fraction représente un nombre respectivement égal ou strictement inférieur à la deuxième fraction.

Avertissement

S’assurer que les fractions sont toujours sous forme réduite.

Remarque : jeu de tests possibles

f1 = Fraction(4, 2)
print(f1)

f2 = Fraction(35, 9)
print(f2)

# Addition de nombres rationnels
f3 = f1 + f2
assert str(f3) == "53 / 9"
# Multiplication de nombres rationnels
f4 = f1 * f2
assert str(f4) == "70 / 9"
# Test de l'égalité de deux nombres rationnels
f5 = Fraction(2, 1)
assert (f1 == f2) == False
assert (f5 == f1) == True
# Teste si un nombre rationnel est plus petit qu'un autre
assert (f1 < f2) == True
assert (f1 < f5) == True

# Test si réduction fonctionne
f6 = Fraction(48, 6)
print(f6)
f7 = Fraction(39, 6)
print(f7)
Physique, Chimie et Informatique > Terminales Spé. NSI > Programmation objet

Résoudre un problème grâce aux paradigmes objet et fonctionnel

L’objectif de ce document est d’illustrer une fois encore l’intérêt des différents paradigmes de programmation.

Cas d’étude : fonction avec paramètres

On considère l’équation qui traduit le mouvement d’une balle lancée verticalement vers le haut avec une vitesse v⃗0\vec{v}_0 depuis l’origine des altitudes telle que l’écrit un physicien :

y(t)=−12g t2+v0 ty(t) = -\dfrac{1}{2}g\, t^2 + v_0\, t

Ce physicien a donc tendance à considérer que yy est une fonction de la variable tt et que cette fonction dépend des paramètres v0v_0 et gg.

  1. Comment définir cette fonction en informatique, sachant que gg est un paramètre fixe g=9,81 m/s2g=\pu{9,81 m/s2} mais que v0v_0 est un paramètre qu’il peut être utile de faire varier ?
    Réponse
    def y(t: float, v0: float) -> float:
        """
        Calcule l'altitude d'une balle lancée vers le haut verticalement avec la vitesse v0 au cours du temps depuis l'origine des altitudes.
    
        REMARQUE : la fonction définit un paramètre constant g = 9.81
        """
        g = 9.81
        return -0.5 * g * t**2 + v0 * t

Problème

Le physicien qui vient de définir la fonction de la question 1. peut vouloir utiliser les fonctions que certains modules, tels que les modules math, numpy ou scipy, proposent. Ces fonctions étant les plus générales possibles, elles implémentent le point de vue du physicien, yy est une fonction de tt, plutôt que celui de l’informaticien, yy est une fonction de tt et de v0v_0. Comment modifier la définition de la fonction y pour qu’elle puisse être utilisée avec n’importe quelle autre fonction ?

Illustration du problème

On peut avoir envie de déterminer la vitesse vy(t)v_y(t) de la balle. La relation mathématique entre vy(t)v_y(t) et y(t)y(t) est la suivante

vy(t)=dydt=y′(t)v_y(t) = \dfrac{\mathrm{d} y}{\mathrm{dt}} = y\rq (t)

vy(t)v_y(t) est la dérivée par rapport au temps de y(t)y(t).

On peut montrer, en analyse numérique, que, en un point d’abscisse x0x_0

f′(x0)≈f(x0+h)−f(x0)hf\rq (x_0) \approx \dfrac{f(x_0 + h) - f(x_0)}{h}
  1. Définir la fonction diff dont la spécification est :
def diff(f: Callable, x0: float, h: float = 1e-7) -> float:
    """
    Calcule la dérivée de la fonction f au point d'abscisse x0.

    REMARQUE : le paramètre h est fixé à h = 1e-7 par défaut.
    """
Réponse
def diff(f: Callable, x0: float, h: float = 1e-7) -> float:
    """
    Calcule la dérivée de la fonction f au point d'abscisse x0.

    REMARQUE : le paramètre h est fixé à h = 1e-5 par défaut.
    """
    return (f(x0 + h) - f(x0)) / h
  1. Tester cette fonction en calculant la dérivée de cos⁡(x)\cos(x) au point x=0x=0. Rappel : (cos⁡(0))′=−sin⁡(0)=0(\cos (0))\rq = -\sin(0) = 0.

    Réponse
    import math as m
    
    print(diff(m.cos, 0))

  2. La fonction diff peut-elle être utilisée pour déterminer la dérivée de la fonction y ?

    Réponse

    Non, puisque diff ne prend que le nom de la fonction à dériver en argument et pas ses paramètres. diff suppose que la fonction f est une fonction à une seule variable.

Première (très mauvaise !) solution : utilisation d’une variable globale

  1. Écrire la fonction y1 dont la spécification est
def y1(t: float) -> float:
    """
    Calcule l'altitude d'une balle lancée vers le haut verticalement avec la vitesse v0 au cours du temps depuis l'origine des altitudes.

    REMARQUE : la fonction définit un paramètre constant g = 9.81

    REMARQUE : la fonction utilise la variable globale v0.
    """
  1. Déterminer la valeur de la vitesse de la balle à la date t=0,1 st=\pu{0,1 s} en utilisant la fonction y1. Remarque : v0=3 m/sv0 = \pu{3 m/s} et la réponse attendue est vy=2,02 m/sv_y = \pu{2,02 m/s}.

    Réponse
    v0 = 3
    t = 0.1
    print(diff(y1, t))

  2. Pourquoi est-ce une mauvaise idée que d’utiliser des variables globales ?

    Réponse

    Une variable globale peut être utilisée et modifiée à plusieurs endroits d’un programme. Il n’est pas toujours facile, lors de l’appel d’une fonction utilisant une variable globale, de savoir exactement quelle est sa valeur.

Deuxième méthode : représenter une fonction par une classe

Sans utilisation des méthodes spéciales

À retenir

Une classe définit un nouveau type et est constituée d’attributs (variables) et de méthodes (fonctions). Les attributs sont accessibles en lecture et en modification par toutes les méthodes ; ce sont des variables globale à la classe !

  1. Définir la classe Y1 dont la spécification est
class Y1:
    """
    Classe représentant la fonction mathématique y.

    Attributs
    ---------
    g : float
        Paramètre g dont la valeur est fixée à l'initialisation de l'objet.
    v0 : float
        Paramètre v0 dont la valeur est récupérée à l'initialisation de l'objet.

    Méthode
    -------
    valeur(self, t: float) -> float
        Retourne la valeur de y à la date t passée en argument.
    """
Réponse
class Y1:
    """
    Classe représentant la fonction mathématique y.

    Attributs
    ---------
    g : float
        Paramètre g dont la valeur est fixée à l'initialisation de l'objet.
    v0 : float
        Paramètre v0 dont la valeur est récupérée à l'initialisation de l'objet.

    Méthode
    -------
    valeur(self, t: float) -> float
        Retourne la valeur de y à la date t passée en argument.
    """

    def __init__(self, v0: float, g: float = 9.81) -> None:
        self.v0 = v0
        self.g = g

    def valeur(self, t: float) -> float:
        """
        Retourne la valeur de y à la date t passée en argument.
        """
        return -0.5 * self.g * t**2 + self.v0 * t
  1. Créer un objet de type Y1 et vérifier que la valeur de la fonction yy à la date t=0,1 st=\pu{0,1 s}, lorsque v0=3 m/sv_0=\pu{3 m/s} est 0,25 m\pu{0,25 m}.

    Réponse
    yo = Y1(3)
    print(yo.valeur(0.1))  # ou assert yo.valeur(0.1) == y(0.1, 3)

  2. Déterminer la vitesse de la balle à cet instant.

    Réponse
    yo = Y1(3)
    print(diff(yo.valeur, 0.1))

En utilisant une méthode spéciale

On peut penser que la définition de la classe Y1 fait trop apparaître le concept d’objet au détriment de celui de fonction. En particulier, l’appel yo.valeur(0.1) n’est pas aussi clair que yo(0.1).
Les classes possèdent cependant, en Python, une méthode spéciale nommée __call__ appelée automatiquement chaque fois que l’on utilise un objet comme une fonction.

  1. Définir la classe Y2 dont le code est proche de celui de Y1 mais qui redéfinit la méthode __call__ à la place de définir la méthode valeur.

    Réponse
    class Y2:
        """
        Classe représentant la fonction mathématique y.
    
        Attributs
        ---------
        g : float
            Paramètre g dont la valeur est fixée à l'initialisation de l'objet.
        v0 : float
            Paramètre v0 dont la valeur est récupérée à l'initialisation de l'objet.
        """
    
        def __init__(self, v0: float, g: float = 9.81) -> None:
            self.v0 = v0
            self.g = g
    
        def __call__(self, t: float) -> float:
            """
            Retourne la valeur de y à la date t passée en argument.
            """
            return -0.5 * self.g * t**2 + self.v0 * t

  2. Déterminer la vitesse de la balle à dans les mêmes conditions qu’à la question 10.

    Réponse
    yo = Y2(3)
    print(yo(0.1))

Troisième méthode : premiers pas dans le monde fonctionnel

À retenir

En programmation fonctionnelle, les fonctions sont des objets de première classe : une fonction peut être passée comme argument à une autre fonction, une fonction peut retourner une fonction.

Étudier le code suivant

def fixe_param(v0: float) -> Callable:
    g = 9.81

    def calcule_y(t: float) -> float:
        return -0.5 * g * t**2 + v0 * t

    return calcule_y


y3 = fixe_param(3)
print(y3(0.1))
  1. Qu’attend comme argument la fonction fixe_param ?

    Réponse

    fixe_param possède le paramètre v0.

  2. Que sont les variables v0 et g pour la fonction calcule_y ?

    Réponse

    Ce sont des variables externes (non locales). En fait calcule_y les considère comme des variables globales (même si elles sont seulement locales à la fonction fixe_param). Le dernier point de ce document précise le vocabulaire.

  3. Quel est le type de y3 ?

    Réponse

    y3 référence une fonction.

  4. Que signifie l’instruction y3(0.1) ?

    Réponse

    y3(0.1) est un appel de fonction. On appelle la fonction référencée par la variable y3 avec l’argument 0.1.

Info

Utiliser le site Pythontutor pour bien comprendre l’effet de chacune des instructions.

  1. Quelles lignes de code faudrait-il modifier si maintenant la balle est lancée à la vitesse v0=5 m/sv_0 = \pu{5 m/s} et que l’on cherche toujours sa position à la date t=0,1 st = \pu{0,1 s} ?

    Réponse
    y5 = fixe_param(5)
    print(y5(0.1))

  2. Quel est le rôle de la fonction fixe_param ?

    Réponse

    fixe_param enveloppe calcule_y, elle permet de réaliser une fermeture (closure).

À retenir

Dans un langage de programmation, une fermeture (en anglais : closure) est une fonction accompagnée de son environnement lexical. L’environnement lexical d’une fonction est l’ensemble des variables non locales qu’elle a capturé, soit par valeur (c’est-à-dire par copie des valeurs des variables), soit par référence (c’est-à-dire par copie des adresses mémoires des variables). Une fermeture est donc créée, entre autres, lorsqu’une fonction est définie dans le corps d’une autre fonction et utilise des paramètres ou des variables locales de cette dernière.

Physique, Chimie et Informatique > Terminales Spé. NSI > Programmation objet

Jeu de la vie

Le but de ce sujet est de réaliser en Python une implémentation du jeu de la vie en utilisant la programmation objet.

Info

Un automate cellulaire consiste en une grille régulière de « cellules » contenant chacune un « état » choisi parmi un ensemble fini et qui peut évoluer au cours du temps. L’état d’une cellule au temps t+1t+1 est fonction de l’état au temps tt d’un nombre fini de cellules appelé son « voisinage ». À chaque nouvelle unité de temps, les mêmes règles sont appliquées simultanément à toutes les cellules de la grille, produisant une nouvelle « génération » de cellules dépendant entièrement de la génération précédente.

Le jeu de la vie a été inventé par le mathématicien britannique John H. Conway (1937-2020). C’est un exemple de ce qu’on appelle un automate cellulaire bidimensionnel. Il se déroule sur un tableau rectangulaire (L×H)(L \times H) de cellules. Une cellule est représentée par ses coordonnées xx et yy qui vérifient 0⩽x<L0 \leqslant x < L et 0⩽y<H0 \leqslant y < H.

Une cellule peut être dans deux états : vivante ou morte. La dynamique du jeu s’exprime par les règles de transition suivantes :

  • une cellule vivante reste vivante à la génération suivante si elle est entourée de 2 ou 3 voisines vivantes et meurt sinon ;
  • une cellule morte devient vivante à la génération suivante si elle possède exactement 3 voisines vivantes.

La notion de « voisinage » dans le jeu de la vie est celle des 8 cases qui peuvent entourer une case donnée (on parle de voisinage de Moore).

Pour implémenter la simulation, on va tout d’abord rechercher une modélisation objet du problème, puis procéder à son implémentation.

Avertissement

Chaque fonction/méthode devra posséder une spécification.

Modélisation objet

  1. Quelles classes peut-on envisager au premier abord pour implémenter ce problème ?

    Réponse

    Les classes Grille et Cellule viennent facilement à l’esprit, on peut penser à une classe Etat représentant l’état d’une cellule si l’on veut pousser la modélisation un peu plus loin.

  2. Quelles méthodes pourrait-on imaginer pour chaque classe ?

    Réponse

    Nous retrouverons ces méthodes dans l’implémentation, mais il faut au moins songer ici aux méthodes qui permettent de récupérer l’état interne des attributs et de les modifier. Il faut aussi penser à la représentation du voisinage d’une cellule et aux méthodes permettant de le modifier ou de le récupérer.

  3. Dans quelle classe pouvons-nous représenter simplement la notion de voisinage d’une cellule ? Et le calculer ?

    Réponse

    Il peut être commode qu’une Cellule connaisse ses voisins, mais une Grille est plus à même de calculer les voisinages. On peut donc définir une méthode de calcul de voisinage dans la Grille et des méthodes pour affecter ou lire la liste des voisins dans la Cellule, ce qui lui permettra de calculer son état futur selon les règles du jeu de la vie.

  4. Une cellule est au bord si x=0x=0, x=L−1x=L-1, y=0y=0 ou y=H−1y=H-1. Combien de voisins possède une cellule qui n’est pas au bord ? Combien de voisins possède une cellule qui est au bord ?

    Réponse

    Une cellule qui n’est pas au bord possède 8 voisins. Une cellule qui est en bordure en possède 3 dans les angles ou 5 ailleurs sur les bords.

  5. Que pourrions-nous aussi considérer comme voisin de droite de la case en haut et à droite de la grille ? Et comme voisin du haut ?

    Réponse

    Nous pourrions considérer que le voisin de la cellule en haut et à droite de la grille est la cellule en haut et à gauche. De même le voisin du haut de la case en haut à droite pourrait être la cellule en bas à droite de la grille (grille torique).

Implémentation du jeu

Avertissement

Chaque classe sera définie dans un fichier différent.

La classe Cellule

  1. Implémenter tout d’abord une classe Cellule avec comme attributs :
    • un booléen actuel initialisé à False ;
    • un booléen futur initialisé à False ;
    • une liste voisins initialisée à None.

Remarque. La valeur False signifie que la cellule est morte et True qu’elle est vivante.

  1. Ajouter les méthodes suivantes :

    • est_vivant qui renvoie l’état actuel (vrai ou faux) ;
    • set_voisins qui permet d’affecter comme voisins la liste passée en paramètre ;
    • get_voisins qui renvoie la liste des voisins de la cellule ;
    • naitre qui met l’état futur de la cellule à True ;
    • mourir qui permet l’opération inverse ;
    • basculer qui fait passer l’état futur de la cellule dans l’état actuel.
  2. Ajouter à la classe Cellule une méthode __str__ qui retourne le caractère "X" si la cellule est vivante et un tiret "-" sinon.
    Expliquer brièvement l’utilité d’une telle méthode __str__ en Python.

  3. Ajouter une méthode calcule_etat_futur dans la classe Cellule qui permet d’implémenter les règles d’évolution du jeu de la vie en préparant l’état futur à sa nouvelle valeur.

La classe Grille

  1. Créer la classe Grille et y définir les attributs suivants :
    • largeur (passé en argument) ;
    • hauteur (passé en argument) ;
    • matrix : un tableau de cellules à 2 dimensions implémenté en Python par une liste de listes.

Remarque : Définir la méthode set_matrix pour construire le tableau. Remarque : Une nouvelle Cellule sera créée par l’appel Cellule().

  1. Ajouter les méthodes :

    • dans_grille qui indique si un point de coordonnées ii et jj est bien dans la grille ;
    • set_cell_xy qui permet d’affecter une nouvelle cellule à la case (i,j)(i,j) de la grille, si (i,j)(i,j) est bien dans la grille ;
    • get_cell_xy qui permet de récupérer la cellule située dans la case (i,j)(i,j) de la grille, si (i,j)(i,j) est bien dans la grille ;
    • get_largeur qui permet de récupérer la largeur de la grille ;
    • get_hauteur qui permet de récupérer la hauteur de la grille ;
    • est_voisin une méthode statique qui vérifie si les cases (i,j)(i,j) et (x,y)(x,y) sont voisines dans la grille.
  2. Ajouter une méthode get_voisins qui renvoie la liste des voisins d’une cellule.

  3. Fournir une méthode set_voisins qui affecte à chaque cellule de la grille la liste de ses voisins.

  4. Donner une méthode __str__ qui permet d’afficher la grille sur un terminal.

  5. On veut remplir aléatoirement la Grille avec un certain taux de Cellule vivantes. Définir une méthode remplir_alea avec le taux (en pourcentage) en argument.

Le jeu

  1. Définir une méthode jeu permettant de passer en revue toutes les Cellules de la Grille, de calculer leur état futur, puis une méthode actualise qui bascule toutes les cellules de la Grille dans leur état futur.

  2. Dans le fichier principal, entrer le code suivant afin de lancer le jeu :

from grille import Grille
import time


def effacer_ecran():
    print("\u001b[H\u001b[J")


def main():
    plateau = Grille(20, 30)
    plateau.remplir_alea(55)
    plateau.set_voisins()
    while True:
        effacer_ecran()
        print(plateau)
        print("\n")
        time.sleep(0.5)
        plateau.jeu()
        plateau.actualise()


main()

Spécifications

  • Classe Cellule
def __init__(self: Cellule) -> None:
    """
    Initialisation des attributs.
    """
def est_vivant(self: Cellule) -> bool:
    """
    Retourne l'état actuel de la cellule.
    """
def set_voisins(self: Cellule, voisins: List[Cellule]) -> None:
    """
    Affecte comme voisins la liste passée en paramètre.
    """
def get_voisins(self: Cellule) -> List[Cellule]:
    """
    Renvoie la liste des voisins de la cellule
    """
def naitre(self: Cellule) -> None:
    """
    Met l’état futur de la cellule à `True`
    """
def mourir(self: Cellule) -> None:
    """
    Met l’état futur de la cellule à `False`
    """
def basculer(self: Cellule) -> None:
    """
    Fait passer l’état futur de la cellule dans l’état actuel
    """
def __str__(self: Cellule) -> str:
    """
    Représentation de l'objet sous forme d'une chaîne de caractères
    """
def calcule_etat_futur(self: Cellule) -> None:
    """
    Implémente les règles d’évolution du jeu de la vie en préparant l’état futur à sa nouvelle valeur
    """
  • Classe Grille
def __init__(self: Grille, largeur: int, hauteur: int) -> None:
    """
    Initialisations des attributs
    """
def set_matrix(self: Grille) -> List[List[Cellule]]:
    """
    Construction de la grille de cellules
    """
def dans_grille(self: Grille, i: int, j: int) -> bool:
    """
    Vérifie que le point de coordonnées (i,j) est dans la grille
    """
def set_cell_xy(self: Grille, i: int, j: int, cellule: Cellule) -> None:
    """
    Affecte une nouvelle cellule à la case (i,j) de la grille
    """
def get_cell_xy(self: Grille, i: int, j: int) -> Cellule:
    """
    Récupère la cellule située dans la case (i,j) de la grille
    """
def get_largeur(self: Grille) -> int:
    """
    Récupère la largeur de la grille
    """
def get_hauteur(self: Grille) -> int:
    """
    Récupère la hauteur de la grille
    """
@staticmethod
def est_voisin(i: int, j: int, x: int, y: int) -> bool:
    """
    Vérifie si les cases (i,j) et (x,y) sont voisines dans la grille
    """
def get_voisins(self: Grille, x: int, y: int) -> List[Cellule]:
    """
    Renvoie la liste des voisins d’une cellule
    """
def set_voisins(self: Grille):
    """
    Affecte à chaque cellule de la grille la liste de ses voisins
    """
def __str__(self: Grille) -> str:
    """
    Représentation de l'objet
    """
def remplir_alea(self, taux: int) -> None:
    """
    Remplir aléatoirement la Grille avec un certain taux de Cellules vivantes
    """
def jeu(self: Grille) -> None:
    """
    Passe en revue toutes les Cellules de la Grille, calcule leur état futur
    """
def actualise(self: Grille) -> None:
    """
    Bascule toutes les cellules de la Grille dans leur état futur
    """

Corrigé

Physique, Chimie et Informatique > Terminales Spé. NSI > Programmation objet

Exercices de programmation objet

Avertissement

Chaque méthode définie devra être accompagnée de sa spécification.

Manipulation de points

On considère la classe nommée Point ayant les attributs suivants :

  • __abs : attribut privé de type float pour représenter l’abscisse du point ;
  • __ord : attribut privé de type float pour représenter l’ordonnée du point.
  1. Définir la class Point et le constructeur __init__ permettant d’initialiser les deux attributs.
Info

L’encapsulation est un concept fondamental de la conception objet. L’idée est de ne pas laisser accessibles les attributs depuis l’extérieur de la classe/objet ; les attributs sont alors dits privés (ou protégés si l’accès est nécessaire dans une sous-classe).

En pratique :

p1 = Point()
p1.__abs = 1  # Interdit
p1.set_abs(1)  # Bonne pratique

En Python, par convention, le nom des attributs privés commence par __.

L’accès et la modification des attributs nécessitent alors la définition de méthodes appellées getters et setters.
Les noms de ces méthodes sont, par exemple pour l’attribut __abs, get_abs et set_abs.

  1. Définir les getters et les setters pour les deux attributs.
    Modifier la méthode __init__ de façon à ce qu’elle utilise les setters.

  2. Définir la méthode __str__ qui retourne la représentation mathématique d’un point sous forme d’une chaîne de caractères : "(abs, ord)".

  3. Définir la méthode calcul_distance qui calcule la distance du point courant à un point passé en argument.
    La signature de la fonction est calcul_distance(self: Point, p: Point) -> float.

Info

On rappelle que la distance entre deux points A(x1,y1)A(x_1, y_1) et B(x2,y2)B(x_2, y_2) est égale à : (x2−x1)2+(y2−y1)2\sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2 }.

  1. Définir la méthode calcul_milieu qui retourne un objet situé à égale distance du point courant et d’un point passé en argument.
    La signature de la fonction est calcul_milieu(self: Point, p: Point) -> Point.
Info

On rappelle que la point situé à égale distance de deux points A(x1,y1)A(x_1, y_1) et B(x2,y2)B(x_2, y_2) a pour coordonnées xM=x1+x22x_M = \dfrac{x_1 + x_2}{2} et yM=y1+y22y_M = \dfrac{y_1 + y_2}{2}.

On considère maintenant la classe nommée TroisPoints ayant les attributs suivants :

  • __premier : attribut privé de type Point ;
  • __deuxieme : attribut privé de type Point ;
  • __troisieme : attribut privé de type Point ;
  1. Définir la class TroisPoints et le constructeur __init__ permettant d’initialiser les trois attributs.

  2. Définir les getters et les setters pour les trois attributs.
    Modifier la méthode __init__ de façon à ce qu’elle utilise les setters.

  3. Définir la méthode sont_alignes qui retourne True si les trois points sont alignés, False sinon.
    La signature de la fonction est sont_alignes(self) -> True.

Info

On rappelle que trois points AA, BB et CC sont alignés si AB=AC+BCAB=AC+BC ou si AC=AB+BCAC=AB+BC ou si BC=AC+ABBC=AC+AB (ABAB, ACAC et BCBC sont des distances).

  1. Définir la méthode est_isocele qui retourne True si les trois points forment un triangle isocèle et False sinon.
Info

On rappelle qu’un triangle est isocèle si AB=ACAB=AC ou AB=BCAB=BC ou AC=BCAC=BC (ABAB, ACAC et BCBC sont des distances).

  1. (Facultatif car HP) Implémenter une version statique (méthodes décorées par le décorateur @staticmethod) des deux méthodes calcul_distance et calcul_milieu.
  1. Tester tous les objets et méthodes depuis la fonction main du programme.

Carnet d’adresses

On considère les deux classes Personne et Adresse.

Les attributs de la classe Adresse sont :

  • __rue : un attribut privé de type chaîne de caractères.
  • __ville : un attribut privé de type chaîne de caractères.
  • __code_postal : un attribut privé de type chaîne de caractères.

Les attributs de la classe Personne sont :

  • __nom : un attribut privé de type chaîne de caractères.
  • __sexe : un attribut privé de type chaîne de caractères (cet attribut aura comme valeur soit ’M’ soit ’F’).
  • __adresses : un attribut privé de type tableau d’objet de la classe Adresse.
  1. Définir les deux classes Adresse et Personne dans deux fichiers différents. Ne pas oublier de définir les getters/setters et les constructeurs.

  2. Définir une troisième classe ListePersonnes ayant un seul attribut personnes : un tableau d’objets Personne.
    Définir les getters/setters et le constructeur de cette classe. La signature de la fonction set_personnes est set_personnes(self, p: Personne) -> None.

  3. Définir la méthode recherche_par_nom, de signature recherche_par_nom(n: str) -> Personne, qui permet de chercher dans le tableau personnes si l’attribut __nom d’un objet de type Personne est égal à la valeur du paramètre n. Si c’est le cas, la méthode retourne le premier objet correspondant, sinon None.

  4. Définir la méthode test_code_postal, de signature test_code_postal(cp: str) -> bool qui permet de vérifier dans le tableau personnes si un objet possède au moins une adresse dont le code postal égal au paramètre cp. Si c’est le cas, elle retourne True, sinon False.

  5. Définir la méthode compte_personne_ville, de signature compte_personne_ville(ville: str) -> int, qui permet de calculer le nombre d’objets dans le tableau personnes ayant une adresse dans la ville passée en paramètre.

  6. Définir la méthode edit_personne_nom, de signature edit_personne_nom(ancien_nom: str, nouveau_nom: str) -> None, qui remplace les noms de personnes ayant un nom égal à la valeur ancien_nom par nouveau_nom.

  7. Définir la méthode edit_personne_ville, de signature edit_personne_ville(nom: str, nouvelle_ville: str) -> None, qui remplace les villes de personnes ayant un nom égal à la valeur du paramètre nom par nouvelle_ville.

  8. Dans la fonction main, tester toutes les méthodes réalisées dans les questions précédentes.

Physique, Chimie et Informatique > Terminales Spé. NSI > Programmation objet

Jeu de dominos

Les dominos

Qu’est-ce que le jeu de dominos ?

Programmation

  1. Écrire le code de la classe Domino telle que le constructeur initialise les variables gauche et droite.

Penser à définir et utiliser une fonction verifie_valeur dont la spécification est

def verifie_valeur(self, val: int, cote: str) -> int:
    """
    Vérifie que la valeur attribuée au Domino est correcte.
    Dans le cas contraire, lève une exception.
    """
  1. Écrire le code de la fonction est_double dont la spécification est
def est_double(self: Domino) -> bool:
    """
    Teste si le domino est double.
    """
  1. Écrire le code de la fonction est_blanc dont la spécification est
def est_blanc(self: Domino) -> bool:
    """
    Teste si le domino est blanc, c'est à dire si ces valeurs gauche et
    droite sont nulles.
    """
  1. Écrire le code de la fonction nbre_points dont la spécification est
def nbre_points(self: Domino) -> int:
    """
    Compte le nombre de points.
    """
  1. Écrire le code de la fonction __str__ suivant
def __str__(self: Domino) -> str:
    """
    Affichage du domino.
    """
    if not self.est_double():
        return """
        ⎡⎺⎺⎺⎺⎺ ⎺⎺⎺⎺⎺⎤
        ⎢  {}  ⎢  {}  ⎥ 
        ⎣⎽⎽⎽⎽⎽ ⎽⎽⎽⎽⎽⎦
        """.format(self.gauche, self.droite)
    else:
        return """
        ⎡⎺⎺⎺⎺⎺⎤
        ⎢  {}  ⎢
        ⎢⎻⎻⎻⎻⎻⎢
        ⎢  {}  ⎢
        ⎣⎽⎽⎽⎽⎽⎦
        """.format(self.gauche, self.droite)
  1. Écrire le code de la classe JeuDominos dont le constructeur initialise la variable nbre_pieces à 28 et crée la variable jeu de type liste de dominos.
    Définir la fonction creation_jeu dont l’objet est la création du jeu.

  2. Écrire le code de la fonction melanger dont la spécification est

def melanger(self: JeuDominos) -> None:
    """
    Mélange aléatoirement le jeu de dominos.
    """
  1. Écrire le code de la fonction distribuer dont la spécification est
def distribuer(self: JeuDominos, nbre_joueurs: int) -> List[Domino]:
    """
    Extractions des dominos attribués à un joueur de la liste des dominos et retour des dominos attribués à ce joueur.
    """
  1. Écrire le code de la fonction affiche_jeu dont la spécification est
def affiche_jeu(self: JeuDominos) -> None:
    """
    Affiche le jeu ou la pioche en fonction de l'avancée du jeu.
    """
  1. Initialiser le jeu, et le mélanger.

  2. Pour le joueur 1, utiliser le code suivant

print("Joueur 1")
print("========")
jeu_j1 = jeu.distribuer(2)
points_joueur_1 = 0
nbre_dominos_blancs_j1 = 0
nbre_dominos_doubles_j1 = 0
for domino in jeu_j1:
    print(domino)
    points_joueur_1 += domino.nbre_points()
    if domino.est_blanc():
        nbre_dominos_blancs_j1 += 1
    if domino.est_double():
        nbre_dominos_doubles_j1 += 1

print(
    f"{points_joueur_1} points possibles, dont {nbre_dominos_blancs_j1} dominos blancs et {nbre_dominos_doubles_j1} dominos doubles."
)
  1. Adapter le code précédent pour le joueur 2.

  2. Afficher la pioche.