Exemple d'exemple

#!/usr/bin/python
# -*- coding: utf-8 -*-

#===============================================
# J’ai plusieurs mamans
#===============================================
class Arme(object):

    def __init__(self, nom, degat):

        self.nom = nom
        self.degat = degat

    def attaque(self, cible): # on retire les degâts de l'épee des points de vie
        cible.vie -= self.degat


class Protection(object):

    def __init__(self, nom, armure):

        self.nom = nom
        self.armure = armure

    def defend(self, degat): # on diminue les degâts, voire on les annule

        degat = degat - self.armure
        if degat < 0:
            return 0

        return degat


epee = Arme('Epée Mana', degat=999)
casque = Protection('Casque de Balduran', armure=1)


class ProtectionOffensive(Arme, Protection):

    def __init__(self, nom, degat, armure):

        Arme.__init__(self, nom, degat) # appelle le __init__ de arme
        Protection.__init__(self, nom, armure) # appelle le __init de protection

        # comme on a appelé les deux __init__, on va avoir les attributs
        # settés dans les deux __init__ attachés à cette classe


bouclier = ProtectionOffensive('Bouclier du dragon', degat=10, armure=100)
print bouclier.degat  # 10
print bouclier.armure  # 10
print bouclier.defend(10)  # 0


#===========================================
# La composition (POO pour les vrais mecs)
#===========================================
class HeroViril(object):

    # def __init__(self, nom, prenom, groupe_sanguin, signe_astrologique,
    #              couleur_preferee, tendance_sexuelle, culte,
    #              taille_de_la_troisieme_phallange_de_l_index_gauche)
    # TODO : voir le CDC avec le client pour confirmer les attributs du personnage
    def __init__(self, nom, vie, arme=None):

        self.nom = nom
        self.vie = vie
        self.arme = arme

    def combattre(self, ennemi):

        print "{} attaque {}".format(self.nom, ennemi.nom)

        while True:

            if self.arme:
                self.arme.attaque(ennemi)

            if ennemi.vie <= 0:
                break

            if ennemi.arme:
                ennemi.arme.attaque(self)

            if self.vie <= 0:
                break

        if self.vie > 0:
            print "Victoire de {}".format(self.nom)
        else:
            print "{} est mort comme une pov' merde".format(self.nom)


# le code de l'armure ne change pas
class Protection(object):

    def __init__(self, nom, armure):

        self.nom = nom
        self.armure = armure

    def defend(self, degat):

        degat = degat - self.armure
        if degat < 0:
            return 0

        return degat


# on change le code de l'arme, si la cible a une protection
# cela diminue les degâts pris
class Arme(object):

    def __init__(self, nom, degat):

        self.nom = nom
        self.degat = degat

    def attaque(self, cible):

        # je mets aussi quelques prints pour le lulz
        if cible.protection:
            degat = cible.protection.defend(self.degat)
            print "{} - {} = {}".format(cible.vie, degat, cible.vie - degat)
            cible.vie -= degat
        else:
            print "{} - {} = {}".format(cible.vie, self.degat, cible.vie - self.degat)
            cible.vie -= self.degat


gosu = HeroViril("Drizzt Do'Urden", 2000)
gosu.arme = Arme('Lame Vorpale', 10)
gosu.protection = Protection("Maille en Kevlar de mithril doré a l'adamantium", 10)
noob_qui_repop = HeroViril("Bob", 200)
noob_qui_repop.arme = Arme('Cure-dent', 1)
noob_qui_repop.protection = Protection("Slip", 1)
noob_qui_repop.combattre(gosu)  # yaaaaaaaaaaaaaaaaaaaaaaa !
#Bob attaque Drizzt Do'Urden
#2000 - 0 = 2000
#200 - 9 = 191
#2000 - 0 = 2000
#191 - 9 = 182
#2000 - 0 = 2000
#182 - 9 = 173
#2000 - 0 = 2000
#173 - 9 = 164
#2000 - 0 = 2000
#164 - 9 = 155
#2000 - 0 = 2000
#155 - 9 = 146
#2000 - 0 = 2000
#146 - 9 = 137
#2000 - 0 = 2000
#137 - 9 = 128
#2000 - 0 = 2000
#128 - 9 = 119
#2000 - 0 = 2000
#119 - 9 = 110
#2000 - 0 = 2000
#110 - 9 = 101
#2000 - 0 = 2000
#101 - 9 = 92
#2000 - 0 = 2000
#92 - 9 = 83
#2000 - 0 = 2000
#83 - 9 = 74
#2000 - 0 = 2000
#74 - 9 = 65
#2000 - 0 = 2000
#65 - 9 = 56
#2000 - 0 = 2000
#56 - 9 = 47
#2000 - 0 = 2000
#47 - 9 = 38
#2000 - 0 = 2000
#38 - 9 = 29
#2000 - 0 = 2000
#29 - 9 = 20
#2000 - 0 = 2000
#20 - 9 = 11
#2000 - 0 = 2000
#11 - 9 = 2
#2000 - 0 = 2000
#2 - 9 = -7
#Bob est mort comme une pov' merde


#=====================================================================
# Ok, j’ai pigé le principe, mais comment ça marche dans le détail ?
#=====================================================================
class HeroViril(object):

    def __init__(self, nom, vie, arme=None):

        self.nom = nom
        self.vie = vie
        self.arme = arme

    # elle attend un ennemi en paramètre, donc UN OBJET HeroViril
    # self est l'objet en cours, donc aussi un objet HeroViril
    def combattre(self, ennemi):

        print "{} attaque {}".format(self.nom, ennemi.nom)

        # une petite boucle infinie. Warning, c'est un tuto. Ne faites pas
        # ça chez vous les enfants.
        # cette boucle loop pour toujours si il n'y a pas d'attribut arme donc
        # ceci n'est qu'un exemple. Hein ? Noté ? Les deux du fond là ?
        while True:

            # on donne le premier coup à la personne qui attaque (l'objet en
            # cours). On vérifie qu'il a une arme. Si c'est le cas,
            # on appelle la méthode de l'arme "attaque()", et on lui passe
            # en paramètre l'ennemi.
            if self.arme:
                self.arme.attaque(ennemi)

            # condition de sortie de la boucle sur la vie du héros qui a pris
            # le coup
            if ennemi.vie <= 0:
                break

            # ensuite on fait pareil à l'envers pour donner une chance à l'autre
            # de répliquer : on vérifie que l'ennemi a une arme, et si c'est
            # le cas, on applique la méthode "attaque" de l'arme à l'objet
            # en cours
            if ennemi.arme:
                ennemi.arme.attaque(self)

            # condition de sortie de la boucle sur la vie du héros qui a pris
            # le coup
            if self.vie <= 0:
                break

        # une fois sorti de la boucle, on vérifie le niveau de vie pour
        # désigner le vainqueur
        if self.vie > 0:
            print "Victoire de {}".format(self.nom)
        else:
            print "{} est mort comme une pov' merde".format(self.nom)


class Arme(object):

    def __init__(self, nom, degat):

        self.nom = nom
        self.degat = degat

    # self est l'objet en cours, donc l'arme
    # cible est un héros, puisqu'on l'a passé en paramètre
    def attaque(self, cible):

        # si la cible (l'objet héros) a un attribut protection,
        # les dégâts retirés sont diminués (ce calcul est fait par la protection)
        if cible.protection:
            cible.vie -= cible.protection.defend(self.degat)

        # sinon, on retire les dégâts à la vie de la cible (le héros)
        # directement
        else:
            cible.vie -= self.degat


class Protection(object):

    def __init__(self, nom, armure):

        self.nom = nom
        self.armure = armure

    # self est l'objet en cours, donc la protection
    # degat est un simple int
    def defend(self, degat):
        # on retourne les degâts infligés, moins la protection
        return degat - self.armure


class ArmeMegaEmpoisonnee(Arme):

    def __init__(self, nom, degat, poison=100000):
        super(ArmeMegaEmpoisonnee, self).__init__(nom, degat)
        self.poison = poison


    def attaque(self, cible):

        # on prend les degâts une premiere fois
        super(ArmeMegaEmpoisonnee, self).attaque(cible)

        # puis on prend les dégâts du poison
        cible.vie -= self.poison


noob_qui_repop.vie = 200 # rePOP !
noob_qui_repop.arme = ArmeMegaEmpoisonnee('Cheat Code', 1)
noob_qui_repop.combattre(gosu) # Vengeance !
#Bob attaque Drizzt Do'Urden
#2000 - 0 = 2000
#Victoire de Bob


#=============================================
# Choisir entre l’héritage et la composition
#=============================================


#=============================================
# Le design pattern “stratégie”
#=============================================
import os

class ParseurXml(object):
    # ...
    pass

class ParseurJson(object):
    # ...
    pass


class ParseurDeFichier(object):

    _strategy = { # les stratégie par défaut
        'json': ParseurXml,
        'xml': ParseurJson
    }

    def __ini__(self, fichier, strategy=None):

        self.fichier = fichier
        # on récupère l'extension du fichier
        path, ext = os.path.splitext(fichier)

        # Strategy est une classe de parseur
        # on la récupère depuis les paramètres ou selon
        # l'extension
        Strategy = strategy or self._strategy[ext]
        # on instancie notre classe de strategie
        self.strategy = Strategy(fichier)

    def parse(self):
        # on délègue le boulot à la stratégie
        self.strategy.parse()