Devoir sur la Programmation Orientée Objet

Exercice 1 (Début sujet bac 2021)

Une agence immobilière développe un programme pour gérer les biens immobiliers qu'elle propose à la vente.

Dans ce programme, pour modéliser les données de biens immobiliers, on définit une classe Bim avec les attributs suivants :

nt de type str représente la nature du bien (appartement, maison, bureau, commerces, … ) ;
sf de type float est la surface du bien ;
pm de type float est le prix moyen par m² du bien qui dépend de son emplacement.

La classe Bim possède une méthode estim_prix qui renvoie une estimation du prix du bien. Le code (incomplet) de la classe Bim est donné ci-dessous :

class Bim:
    def __init__(self, nature, surface, prix_moy):
        ...

    def estim_prix(self):
        return self.sf * self.pm

Recopier et compléter le code du constructeur de la classe Bim.

Correction

def __init__(self, nature, surface, prix_moy):
    self.nt=nature
    self.sf=surface
    self.pm=prix_moy

On exécute l'instruction suivante :
```
b1 = Bim('maison', 70.0, 2000.0)
```
Que renvoie l'instruction b1.estim_prix() ? Préciser le type de la valeur renvoyée.

Correction

b1.estim_prix() retourne 140000.0 qui est du type float
On souhaite affiner l'estimation du prix d'un bien en prenant en compte sa nature :
- pour un bien dont l'attribut nt est 'maison' la nouvelle estimation du prix est le produit de sa surface par le prix moyen par m² multiplié par 1,1 ;
- pour un bien dont l'attribut nt est 'bureau' la nouvelle estimation du prix est le produit de sa surface par le prix moyen par m² multiplié par 0,8 ;
- pour les biens d'autres natures, l'estimation du prix ne change pas.
Modifier le code de la méthode estim_prix afin de prendre en compte ce changement de calcul.
Correction
```
def estim_prix(self):
    tx=1
    if self.nt=='maison':
        tx=1.1
    if self.nt=='bureau':
        tx=0.8
    return self.sf * self.pm*tx
```

Exercice 2 (Sujet bac Asie J1 2022 modifié)

Un fabricant de brownies au chocolat décide d'informatiser sa gestion des stocks. Il écrit pour cela un programme en langage Python. Une partie de son travail consiste à développer une classe Stock dont la première version est la suivante :

class Stock:
    def __init__(self):
        self.qt_farine = 0 # quantité de farine initialisée à 0 g
        self.nb_oeufs = 0 # nombre d'oeufs (0 à l'initialisation)
        self.qt_nut = 0 # quantité de pâte à tartiner chocolat noisette initialisée à 0 g

Écrire une méthode ajouter_nut(self, qt) qui ajoute la quantité qt de pâte à tartiner chocolat noisette à un objet de la classe Stock.

On admet que l'on a écrit deux autres méthodes ajouter_farine et ajouter_oeufs qui ont des fonctionnements analogues.
Correction
```
def ajouter_nut(self, qt):
    self.qt_nut=self.qt_nut+qt
```

Écrire une méthode afficher qui affiche la quantité de farine, d'oeufs et de pâte à tartiner chocolat noisette d'un objet de type Stock. L'exemple ci-dessous illustre l'exécution de cette méthode dans la console :

>>> mon_stock = Stock()
>>> mon_stock.afficher()
farine: 0
oeuf: 0
pâte à tartiner chocolat noisette: 0
>>> mon_stock.ajouter_nut(560)
>>> mon_stock.afficher()
farine: 0
oeuf: 0
pâte à tartiner chocolat noisette: 560

Correction

def afficher(self):
    print("farine:",self.qt_farine)
    print("oeuf:",self.nb_oeufs)
    print("pâte à tartiner chocolat noisette:",self.qt_nut)

Pour faire un brownie fondant au chocolat, il faut \(80\) g de farine, \(205\) g de pâte à tartiner chocolat noisette et \(2\) oeufs.

Écrire une méthode stock_suffisant_brownie qui renvoie un booléen True s'il y a assez d'ingrédients dans le stock pour faire un brownie et False sinon.
Correction
```
def stock_suffisant_brownie(self):
    return self.qt_farine>=80 and self.nb_oeufs>=2 and self.qt_nut>=205
```

On considère la méthode supplémentaire produire de la classe Stock donnée par le code suivant :

def produire(self): 
    res = 0 
    while self.stock_suffisant_brownie():
        self.qt_nut = self.qt_nut - 205
        self.qt_farine = self.qt_farine - 80 
        self.nb_oeufs = self.nb_oeufs - 2 
        res = res + 1 
    return res

On considère un stock défini par les instructions suivantes :

>>> mon_stock=Stock()
>>> mon_stock.ajouter_nut(2000)
>>> mon_stock.ajouter_farine(600)
>>> mon_stock.ajouter_oeufs(17)

On exécute ensuite l'instruction mon_stock.produire()

Quelle valeur s'affiche dans la console ? Que représente cette valeur ?

On exécute ensuite l'instruction mon_stock.afficher()

Que s'affiche-t-il dans la console ?

Correction

17//2=8
600//80=7
2000//205=9

Dans la console, il s'affiche donc 7 qui est le nombre de brownies que l'on peut produire avec ce stock.

17-2*7=3
600-80*7=40
2000-205*7=565

À l'affichage, on obtiendra donc:

>>> mon_stock.afficher()
farine: 40
oeuf: 3
pâte à tartiner chocolat noisette: 565

L'industriel possède n lieux de production distincts et donc n stocks distincts.

On suppose que ces stocks sont dans une liste dont chaque élément est un objet de type Stock.

Écrire une fonction Python nb_brownies possédant pour unique paramètre la liste des stocks liste_stocks et renvoyant le nombre total de brownies produits.
Correction
```
def nb_brownies(L):
    S=0
    for e in L:
        S=S+e.produire()
    return S
```