Discussion :

[haulier]

Bonjour à tous,
Voila j'avais commencer à apprendre PYTHON j'étais vraiment à fond dedans je lui suis toujours d'ailleurs . Je me suis arrêter de lire les tutos pour commencer à coder mon premier petit jeu ( MORPION ) qui marche très bien d'ailleurs exploiter mes Nouvelles connaissances. Mon jeu fini je recontinue donc mon apprentissage en tombant nez à nez avec les CLASSSES. Et la viens mon premier problème Je ne comprend absolument pas se qu'une classe peut bien apporter. J'ai pourtant lu 3 tutos différent parlant de se chapitre.

Le but c'est quoi ?
Chaque fonction placer dans une classe s'exécute que si la classe et appeler ? et pas les autres ? Mais dans se cas Une paire de fonction provoque le même boulot.
Une réatribution de variable ? Le global N'est pas suffisant pour ceci ?
Si quelqu'un pourrait être un peu plus explicite avec un tout petit exemple et l'expliquer son fonctionnement car la je sêche et je pense que je vais en avoir grandement besoin

Cordialement merci

[monnomamoi]

Salut,

Expliquer l'intérêt des classes est assez complexe. Comme tu l'as remarqué, tu peux très bien te passer de classes dans un programme. Cependant, elles offrent une méthodologie très utile pour organiser son programme.


Un des intérêts, c'est l'encapsulation. Elle permet de stocker les données d'un objet "séparément" du reste du programme, ce qui permet de les gérer plus facilement.
Par exemple, dans un jeu de stratégie, tu peux avoir besoin de définir des unités :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
class Unite:
    def __init__(self, x, y):
        self.pos_x = x
        self.pos_y = y
    def deplacer(self, dx, dy):
        self.pos_x += dx
        self.pos_y += dy
 
u1 = Unite(1, 2)
u2 = Unite(2, 2)
 
print u1.pos_x, u1.pos_y
u1.deplacer(1, -1)
print u1.pos_x, u1.pos_y

Ici, la position (pos_x, pos_y) est propre à l'instance de classe que tu crées. Tu as une méthode "deplacer" qui permet de modifier les attributs de position en agissant directement sur l'objet concerné. Les données relatives à un objet sont donc gardées bien au chaud ("encapsulées") à l'intérieur même de ton objet. C'est beaucoup plus propre, plus lisible et plus compréhensible que d'avoir par exemple un simple tableau de 2xN éléments qui recense les coordonnées de tes unités...


Un autre avantage est l'héritage de classe. Tu peux créer une classe en se basant sur une classe "mère" en lui ajoutant des fonctionnalités. Par exemple, un soldat, c'est une unité avec des munitions :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class Soldat(Unite):
    def __init__(self, x, y, m):
        Unite.__init__(self, x, y)
        self.munitions = m
    def tirer(self):
        print "Pan !"
        self.munitions -= 1
 
s1 = Soldat(1, 2, 100)
s1.deplacer(1, -1)
s1.tirer()
print s1.munitions

=> Le soldat, c'est à la base une unité (il a une position, il peut de déplacer...) et en plus il a un stock de munitions qui diminue quand il tire.


Bref, la programmation orientée objet (~= quand on programme avec des classes) a énormément d'avantages, mais c'est avant tout une manière de programmer. Je pense que tu en saisiras vraiment l'intérêt lorsque tu auras des programmes plus complexes à faire

[N.tox]

Le but des classes est simple : simplifier la vie des programmeurs, permettre une plus grande clarté et une meilleur maniabilité...

Plus concretement, quand par exemple tu affecte un string à une variable (ou même sans l'assigner d'ailleurs...) cette variable peut utiliser des fonctions spécifiques au strings, et uniquement à ces derniers. C'est parceque string est une classe (mais elle, prédéfinie donc automatiquement crée...).

Les truc vraiment intéressant avec les classes c'est que l'on créer de nouveaux type d'objets (la plupart du temps) qui peuvent eux-même dériver d'autre types et ainsi hériter de leur méthodes (fonctions dans une classe). On peut par exemple créer une classe qui se comporte comme un dictionnaire, mais faire en sorte que les clés de ce dernier soient classés par ordre alphabetique...

Avec les méthodes spéciales (__init__ en fait partie, mais c'est sûrment la plus basique...) on peut vraiment faire de très bonnes choses.

Quoi qu'il en soit, on peut très bien s'en sortir sans classes, mais ce serait se priver de quelque chose de fort utile, et d'autres fois vraiment se compliquer la vie...

voici un exemple (de quelque chose qui reste tout à fait inutile, mais là n'est pas le but):

la classe (avec plusieurs méthode spéciales, ça montre je trouve, vraiment la puissance pratique potentielle des classes ):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Useless(object):
    def __init__(self,_float=None,_int=None,other=None):
        self._float=[] if _float is None else _float
        self._int=[] if _int is None else _int
        self.other=[] if other is None else other
    def __call__(self, value=None):
        if value is None:
            return self._float+self._int+self.other
        else:
            if type(value)==float:
                self._float.append(value)
            elif type(value)==int:
                self._int.append(value)
            else:
                self.other.append(value)
    def __iter__(self): return iter(self._float+self._int+self.other)
 
    def __add__(self,other):
        self(other)
        return self
    def __radd__(self,other):self.__add__(other)
 
    def remove(val):
        if val in self._float: self._float.remove(val)
        elif val in self._int: self._int.remove(val)
        elif val in self.other: self.other.remove(val)

le code d'exemple d'utilisation de la classe

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
a=Useless()
b=Useless(other=['foo1','foo2'])
a(5)
a(7)
a(18.5)
print a()
print b()
for x in a :print x
a+25+106+580
print a()

Et le résultat affiché par les précédentes instructions

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
[18.5, 5, 7]
['foo1', 'foo2']
18.5
5
7
[18.5, 5, 7, 25, 106, 580]

EDIT : grilled , qué yé souis long à rédiyer...
EDIT2 : essayes donc de faire la même choses juste avec des fonctions...tu pourra arriver à un résultat similaire, mais tu verra que c'est beaucoup moins pratique

[haulier]

Merci pour toute c'est infos,
J'espère que cela m'aura apporter assez pour comprendre quand je vais reprendre le tutos d'ici 10 - 15 min ^^.

J'ai bien piger maintenant que la CLASSE servait a rendre plus facile la vie
et que je pouvais obtenir la même chose avec les fonctions global DEF etc ...

Un grand merci à vous deux

[dragonno]

oui mais global def ça crée une variable globale non ?
c'est pas conseillé en programmation à ce qu'on m'a dit.