<br />
<b>Deprecated</b>:  Assigning the return value of new by reference is deprecated in <b>/srv/www/u-classroom.net/wiki/inc/parserutils.php</b> on line <b>208</b><br />
<br />
<b>Deprecated</b>:  Assigning the return value of new by reference is deprecated in <b>/srv/www/u-classroom.net/wiki/inc/parserutils.php</b> on line <b>211</b><br />
<br />
<b>Deprecated</b>:  Assigning the return value of new by reference is deprecated in <b>/srv/www/u-classroom.net/wiki/inc/parserutils.php</b> on line <b>421</b><br />
<br />
<b>Deprecated</b>:  Assigning the return value of new by reference is deprecated in <b>/srv/www/u-classroom.net/wiki/inc/parserutils.php</b> on line <b>594</b><br />
<br />
<b>Deprecated</b>:  Function split() is deprecated in <b>/srv/www/u-classroom.net/wiki/inc/auth.php</b> on line <b>154</b><br />
<br />
<b>Warning</b>:  Cannot modify header information - headers already sent by (output started at /srv/www/u-classroom.net/wiki/inc/parserutils.php:208) in <b>/srv/www/u-classroom.net/wiki/inc/auth.php</b> on line <b>245</b><br />
<br />
<b>Warning</b>:  Cannot modify header information - headers already sent by (output started at /srv/www/u-classroom.net/wiki/inc/parserutils.php:208) in <b>/srv/www/u-classroom.net/wiki/inc/actions.php</b> on line <b>370</b><br />
<br />
<b>Warning</b>:  Cannot modify header information - headers already sent by (output started at /srv/www/u-classroom.net/wiki/inc/parserutils.php:208) in <b>/srv/www/u-classroom.net/wiki/inc/actions.php</b> on line <b>374</b><br />
=====Python: organisation=====

**fichier exemple: [[http://u-classroom.net/cours/langages/pouet.py|pouet.py]]**

====Modules====

Python n'est pas un bloc monolithique, mais est composé de modules. Ces modules peuvent être importés dans les scripts avec l'instruction 'import'. Par exemple :
<code python>import sys, os</code>

Ceci importera les modules 'sys' et 'os' (deux modules très utiles). Toutes les variables/fonctions/classes/etc que contiennent ces modules seront alors accessibles.
Dans le script, on appelle les éléments de ces modules (constantes, fonction) en faisant précéder leur nom par le nom du module et un '.' :
<code python>
os.listdir("/")
os.path.isdir("/bin")
sys.path
</code>

La variable sys.path donne des informations importantes pour l'inclusion. En effet, python doit savoir où se trouvent les modules à importer, et la variable sys.path fournit une liste des emplacements où python cherchera les modules. On peut bien sûr compléter la liste pour ajouter un chemin particulier.

Il arrive qu'on ait besoin que d'un simple élément dans un module. Par exemple la fonction 'exit' du module 'sys'. Avec un import standard on aurait par exemple :
<code python>
import sys
sys.exit(0)
</code>

On pourrait utiliser :
<code python>
from sys import exit
exit(0)
</code>

On peut même donner le nom que l'on veut au module importé :
<code python>
from os import path as p
p.join("hello", "world")
</code>

On peut également importer plusieurs élément d'un module en les séparant par une virgule :

<code python>from os import listdir, path</code>

====Classes====

La programmation orientée objet est un moyen efficace d'organiser son code. On a déjà utilisé des objets dans les cours précédents (les chaînes de caractère par exemple). Tout est objet en Python.
Un objet est aussi appelé une 'instance de classe'. Une classe est en fait la description générique d'un objet. Elle décrit les variables et les fonctions qui lui sont associées.
Une classe se définit grâce au mot clé 'class' :
<code python>
class Pouet:
    variable1 = 1
    variable2 = 2

    def get_vars(self):
        return (variable1, variable2)
</code>

Pour créer une instance de cette classe (un objet), on utilise la syntaxe suivante :
<code python>
pouet = Pouet()
print pouet.get_vars()
</code>

Même s'il n'existe pas de règle, les noms de classes commencent en général par une majuscule. Les objets étant un type de variables, ils sont nommés en utilisant uniquement des minuscules.

Dans la définition de classe ,chaque variable et méthode de l'objet doit être utilisée avec le mot clef 'self'. Pour toutes les méthodes, le premier argument est 'self' dans la déclaration de cette méthode, mais il est omis lors de l'appel.

Certaines méthodes ont des rôles particulier.

===__init__===

La méthode __init__ est un constructeur, elle est appelée lorsque une nouvelle instance de classe est créée :

<code python>
class Pouet:
    def __init__(self, foo=0, bar=0):
        self.foo = foo
        if foo >= 0:
            self.bar = bar
        else:
            self.bar = -bar
</code>

===__str__===

La méthode __str__ doit retourner une chaîne de caractères qui sera affichée lors d'un appel à 'print objet' :
<code python>
    def __print__(self):
        return "foo: %s, bar: %s" % (self.foo, self.bar)
</code>

Ce qui donnera :
<code python>
>>> p = Pouet(-8, 6)
>>> print p
foo: -8, bar: -6
</code>

===autres===

On peut également redéfinir les opérateurs numériques pour les utiliser comme on le ferait avec des entiers (par exemple) :
<code python>
    def __add__(self, other):
        n = Pouet()
        n.bar = self.bar + other.bar
        n.foo = self.foo + other.foo
        return n
</code>
<code python>
>>> p = Pouet(-8, 6)
>>> q = Pouet(-8, 6)
>>> print p+q
foo: -16, bar: -12
</code>

cf. : http://docs.python.org/ref/numeric-types.html http://docs.python.org/ref/numeric-types.html pour toutes les méthodes.

====Héritage====

Le principe d'héritage est assez simple à comprendre avec un exemple.
Un chien et un oiseau ont tous les deux des pattes, des yeux, peuvent émettre un cri, etc. mais l'oiseau a une couleur de plumage, alors que le chien a une couleur de pelage. Ces deux animaux ont suffisamment en commun pour faire partie d'une 'meta' catégorie (animal) dont des dérivés existeraient (chien et oiseau). C'est le principe de l'héritage.

Voici la même chose en python avec les classes 'Bik' et 'Bok' dérivées de notre classe 'Pouet' :

<code python>
class Bik(Pouet):
    self.specific = 1

class Bok(Pouet):
    self.specific = 2
</code>

Résultat :

<code python>
>>> bik = Bik()
>>> bok = Bok()
>>> print bik.specific, bok.specific
1 2
>>> print bik
foo: 0, bar: 0
</code>

Les attributs de Pouet sont accessibles dans Bik et Bok.

Il peut arriver qu'un attribut ou une méthode de la classe mère doive être modifié pour une classe fille. Il suffit de modifier cet attribut. On peut par exemple modifier la façon donc on affiche le contenu de Bok :
<code python>
class Bok(Pouet):
    self.specific = 2

    def __str__(self):
      return "Bonjour, je suis Bok"
</code>

Résultat :
<code python>
>>> bik = Bik(4, -7)
>>> bok = Bok(5, 6)
>>> print bik
foo: 4, bar: -7
>>> print bok
Bonjour, je suis Bok
</code>

====Dynamisme====

Les objets en python sont dynamiques, c'est à dire que de nouveaux peuvent être définis à la volée :
<code python>
>>> bik.random
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: Bik instance has no attribute 'random'
>>> bik.random = "I'm random"
>>> bik.random
"I'm random"
</code>

L'attribut 'random' a été ajouté à bik. ATTENTION, c'est bien l'objet qui a été modifié, pas la classe :

<code python>
>>> blo = Bik()
>>> blo.random
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: Bik instance has no attribute 'random'
</code>

L'ensemble des attributs d'un objet ou d'une classe est accessible par l'attribut __dict__ :

<code python>
>>> p = Pouet(1, 1)
>>> p.__dict__
{'foo': 1, 'bar': 1}
</code>

Et la fonction dir donne la liste des attributs et méthodes:
<code python>
>>> dir(p)
['__add__', '__doc__', '__init__', '__module__', '__str__', 'bar', 'foo']
</code>