modèle objet de python

algo/poo/cours/DesignPatterns.txt

@@ -0,0 +1,94 @@
+Les design patterns
+=====================
+
+Les design patterns **ne sont pas** indépendants du langage.
+Ils dépendent de l'implémentation.
+
+Le duck typing
+-------------------
+
+En python, le duck typing est une forme extreme de programmation par interface.
+Ne pas hériter dans des directions fausse
+
+exemple : une voiture ne peut hériter d'un moteur, parce que un moteur n'est pas une voiture.
+
+hold or wrap ?
+--------------
+
+**hold**::
+
+    O.S.method()
+
+Cela induit un couplage fort (cf la loi de Demeter)
+
+.. important:: law of Demeter : never more than one dot.
+
+wrap : a hold by private name, with a::
+
+    self.S.method()
+
+Ou bien une méthode getattr::
+
+    __getattr__()
+
+Gets coupling right.
+
+
+wrapper can restrict, inheritance cannot restrict
+--------------------------------------------------
+
+::
+
+    class RestrictingWrapper(object):
+
+      def __init__(self, w, block):
+        self._w = w
+        self._block = block
+
+      def __getattr__(self, n):
+        if n in self._block:
+          raise AttributeError, n
+        return getattr(self._w, n)
+
+Pattern de création : singleton
+-------------------------------
+
+# utiliser un module au lieu d'une classe
+
+in `toto.py`::
+
+    class Toto()
+    toto = Toto()
+
+in another module::
+
+    from toto import toto
+
+la factory
+--------------
+
+::
+
+    def load(pkg, obj):
+        m = __import__(pkg, {}, {}, [obj])
+        return getattr(m, obj)
+
+    cls = load('p1.p2.p3', 'c4')
+
+
+template method (self delegation)
+---------------------------------
+
+# Abstract base class::
+
+  def OrganiseMethod()
+    def org_method():
+       def do_this()
+       def do_that()
+
+  def Concrete(OrganiseMethod)
+      def do_this(): ...
+      def do_that(): ...
+
+il est préférable de lever une NotImplementedError, ce qui revient à faire
+une classe abstraite.

algo/poo/cours/cesar.py

@@ -1,61 +0,0 @@
-# coding: utf-8
-minuscules = 'abcdefghijklmnopqrstuvwxyz'
-majuscules = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-
-def rotation(chaine, x):
-    """
-     Effectue une rotation de x caractères vers la droite:
-     >>> rotation('abcde', 2)
-     'cdeab'
-    """
-    return chaine[x:] + chaine[:x]
-
-def index(c, chaine):
-    """
-     Trouve l'index de c dans la chaine:
-     >>> index('n', 'bonjour')
-     2
-    """
-    for i in range(len(chaine)):
-        if (c == chaine[i]):
-            return i
-    return -1
-
-def chiffre_minuscules(chaine, x):
-    """
-     Chiffre une chaîne composée de minuscules
-     >>> chiffre_minuscules('bonjour', 3)
-     'erqmrxu'
-    """
-    r = rotation(minuscules, x)
-    resultat = ''
-    for lettre in chaine:
-        resultat = resultat + r[index(lettre, minuscules)]
-    return resultat
-
-def chiffre(chaine, x):
-    """
-     Chiffre une chaîne quelconque
-     >>> chiffre('Bonjour les amis!', 3)
-     'Erqmrxu ohv dplv!'
-    """
-    r_min = rotation(minuscules, x)
-    r_maj = rotation(majuscules, x)
-    resultat = ''
-    for lettre in chaine:
-        if lettre in minuscules:
-            resultat = resultat + r_min[index(lettre, minuscules)]
-        elif lettre in majuscules:
-            resultat = resultat + r_maj[index(lettre, majuscules)]
-        else:
-            resultat = resultat + lettre
-    return resultat
-
-#############################################################################
-# Programme principal
-#############################################################################
-print(chiffre_minuscules('bonjour', 3))
-print(chiffre('Bonjour les amis!', 3))
-print(chiffre('Erqmrxu ohv dplv!', 23))
-print(chiffre('Eudyr, yrxv dyhc ilql fhw hahuflfh!', 23))
-

algo/poo/cours/classes.txt

@@ -0,0 +1,452 @@
+Définir et manipuler des classes
+=================================
+
+.. glossary::
+
+    objet
+
+        Un object est une entité possédant un type, un état, et un comportement.
+        Un object correspondant généralement à une entité du monde réel, mais
+        cette entité peut être abstraite.
+        On parle aussi d'**instance**.
+
+**état d'un objet** : ensemble de propriétés auxquelles sont associées des
+valeurs.
+
+Les variables de l'objet sont appelées des **attributs**.
+le comportement d'un :term:`objet` :
+
+- des actions effectuées sur l'objet
+- des appels faits sur l'objet
+
+envois de messages à l'objet = appel de **méthodes**
+
+programmation objet (première approche)
+-----------------------------------------
+
+
+- le type et le protocole d'un objet sont définis par sa classe
+- une classe possède un ensemble d'attributs et de méthodes
+
+deux relations possibles
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+.. glossary::
+
+    heritage
+
+        relation "est une espèce de " utilisée entre une classe et une autre classe
+
+    instantiation
+
+        relation "est une instance de " entre un objet et une classe
+
+
+- est une instance de (objets par rapport à classe)
+- est une espèce de (classe par rapport à classe, :term:`heritage`)
+
+**instance**
+
+- définition d'une classe
+- instance de classe : on peut créer des objets à partir d'un type "classe"
+  (une classe est instanciable)
+
+>>> class A:
+...   pass
+...
+>>> a = A()
+
+:term:`heritage` : notation en python
+
+>>> class A: pass
+...
+>>> class B(A): pass
+...
+>>> b = B()
+>>> type(b) == B
+>>> isinstance(b, A) == True
+
+possibilité en python d'héritage multiple::
+
+    class A(B, C): pass
+
+
+attribut d'objets et de classes
+----------------------------------
+
+>>> o = object()
+>>> o
+<object object at 0x7f77c9cda0d0>
+>>> class C(object): pass
+... 
+>>> class C: pass
+... 
+>>> c = C()
+>>> c.a = 3
+>>> c.a
+3
+>>> vars(c)
+{'a': 3}
+>>> c.__dict__
+{'a': 3}
+>>> C.__dict__
+{'__module__': '__main__', '__doc__': None}
+>>> C.c = 5
+>>> C.__dict__
+{'c': 5, '__module__': '__main__', '__doc__': None}
+>>> c.c
+5
+>>> c.z = 3
+>>> c.z
+3
+>>> c.__dict__
+{'a': 3, 'z': 3}
+>>> C.__dict__
+{'c': 5, '__module__': '__main__', '__doc__': None}
+>>> class MaKlass:
+...   def unefonction(self, x):
+...     print x 
+... 
+>>> MaKlass.__dict__
+{'__module__': '__main__', '__doc__': None, 'unefonction': <function unefonction at 0x7f77c5b0c488>}
+>>> k = MaKlass()
+>>> k.__dict__
+{}
+>>> def autrefonc(self, x)
+  File "<stdin>", line 1
+    def autrefonc(self, x)
+                         ^
+SyntaxError: invalid syntax
+>>> def autrefonc(self, x):
+...   print x
+... 
+>>> k.autrefonc = autrefonc
+>>> k.__dict__
+{'autrefonc': <function autrefonc at 0x7f77c5b0c500>}
+>>> MaKlass.__dict__
+{'__module__': '__main__', '__doc__': None, 'unefonction': <function unefonction at 0x7f77c5b0c488>}
+>>> MaKlass.unefonction(k, "toto")
+toto
+>>> k.unefonction("toto")
+toto
+>>> k.__dict__
+{'autrefonc': <function autrefonc at 0x7f77c5b0c500>}
+>>> MaKlass.toto = "test"
+>>> k.__dict__
+{'autrefonc': <function autrefonc at 0x7f77c5b0c500>}
+>>> k.toto
+'test'
+>>> 
+
+
+le __dict__ avec l'héritage de classe 
+-------------------------------------------
+
+
+>>> class A(object): pass
+... 
+>>> A.__dict__
+dict_proxy({'__dict__': <attribute '__dict__' of 'A' objects>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None})
+>>> class B(A): 
+...   b = 3
+... 
+>>> class C(B):
+...   c = 2
+... 
+>>> c = C()
+>>> o = C()
+>>> o.__dict__
+{}
+>>> o.c
+2
+>>> o.b
+3
+>>> o.__class__
+<class '__main__.C'>
+>>> o.__class__.__dict__
+dict_proxy({'__module__': '__main__', 'c': 2, '__doc__': None})
+>>> 
+
+
+method resolution object 
+-----------------------------
+
+>>> class A(object): pass
+... 
+>>> A.__mro__
+(<class '__main__.A'>, <type 'object'>)
+>>> class B(A): pass
+... 
+>>> B.__mro__
+(<class '__main__.B'>, <class '__main__.A'>, <type 'object'>)
+>>> class C(A, B): pass
+... 
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: Error when calling the metaclass bases
+    Cannot create a consistent method resolution
+order (MRO) for bases A, B
+>>> 
+
+
+introspection contre encapsulation
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+voir un objet comme un espace de nommage. C'est plus **agile**.
+
+attributs et méthodes vus comme des ajouts dans l'espace de nommage
+
+>>> a.a = 2
+>>> def function(x):
+...   print x
+...
+>>> a.f = function
+>>> a.f("hello")
+hello
+>>>
+
+
+la nécessité d'un design objet
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+affichage d'une calculette, il faut créer un type `Touche`
+qui contient deux désignations : `Chiffre` et `operation`::
+
+  type operation = Plus | Moins | Divise
+  type touche = Chiffre of int | Memoire | Op of operation
+
+soit, on définit un type touche, soit on ne définit pas ce type::
+
+  type operation = Plus | Moins | Divise
+  type memoire = Memoire
+  type chiffre = Chiffre
+
+- les structures de données (int, str, list, dict...) : types de base
+- les structures de données utilisateur : les classes !
+
+.. function:: type (objname)
+
+    :param objname: l'objet dont on veut connaître le type
+
+Manipulations sur les classes et les objets
+---------------------------------------------
+
+En python un type et une classe c'est la même chose. Une classe
+est un type standard. En python tout est objet, et tout provient d'un seul objet
+(qui s'appelle ``object``).
+
+- encapsulation (cacher les attributs (variables d'état)) d'un objet.
+
+- interfaces : chaque aspect d'une classe peut être vu comme une interface.
+
+Une interface décrit un ensemble de comportements.
+on peut considérer une interface comme un protocole d'utilisation d'un objet
+dans un contexte donné.
+
+on peut alors créer des outils qui sauront traiter n'importe quel objet
+pourvu qu'il respecte une ensemble d'interfaces.
+
+.. todo:: travailler l'héritage, l'aggrégation, la délégation
+
+Voici un exemple de classe `Voiture` :
+
+.. literalinclude:: snippets/heritage.py
+    :pyobject: Voiture
+
+j'instancie ma classe `Voiture` :
+
+>>> ma_voiture = Voiture("ma_marque", "150km/h")
+>>> ma_voiture.roule()
+'vroummm'
+>>> ma_voiture.signaletique()
+'constructeur : ma_marque, vitesse_max 150km/h'
+
+.. todo:: faire des traitements dans l'init
+
+- héritage (est une sorte de)
+- polymorphisme : un objet apparait comme une instance d'une classe parente
+
+.. literalinclude:: snippets/heritage.py
+    :pyobject: Turbo
+
+>>> v = DoDoche("marque", 160)
+>>> v.get_prix()
+'7000'
+>>> isinstance(v, Prix)
+True
+>>>
+
+mais l'objet conserve son identité :
+
+>>> type(v)
+<type 'Voiture'>
+
+la fonction ``achete_voiture()`` sera appelée indépendamment du type de l'objet,
+du moment que l'objet a une méthode `get_prix()`, c'est le duck typing, qu'il
+est préférable de ramener au polymorphisme d'objet, ou bien utiliser les :mod:`abc`
+(abstract base classes).
+
+.. literalinclude:: snippets/heritage.py
+    :pyobject: achete_voiture
+
+tout le code :
+
+.. literalinclude:: snippets/heritage.py
+
+:download:`télécharger le code <snippets/heritage.py>`
+
+- **l'aggrégation**
+
+un attribut est lui-même un objet (ce qui est fréquent en python)...
+
+.. literalinclude:: snippets/aggregation.py
+
+- **la délégation**
+
+la fonction "property" est un élément du design de python lui-même
+
+.. function:: property()
+
+les patrons de conception
+---------------------------
+
+- le patron **factory**
+
+.. literalinclude:: snippets/patrons.py
+
+:download:`télécharger usine (factory) <snippets/patrons.py>`
+
+- le patron **wrapper**
+
+:download:`télécharger wrapper <snippets/wrap.py>`
+
+.. literalinclude:: snippets/wrap.py
+
+exemple d'utilisation de `Wrap()`
+
+>>> class O:
+...   pass
+...
+>>> o = O()
+>>> o.a = "blah"
+>>>
+>>> from wrap import Wrap
+>>> w = Wrap("monwrap", o)
+>>> w._name
+'monwrap'
+>>> w._w
+<__main__.O instance at 0x7fbf177aaa28>
+>>> w._w.a
+'blah'
+>>> w.a
+'blah'
+>>> w.u
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+  File "wrap.py", line 11, in __getattr__
+    return getattr(self._w, name)
+AttributeError: O instance has no attribute 'u'
+>>>
+
+- le patron de conception **itérable**
+
+:download:`télécharger iterable <snippets/iterable.py>`
+
+.. literalinclude:: snippets/iterable.py
+
+- le patron **decorateur**
+
+:download:`télécharger decorateur <snippets/decorateur.py>`
+
+.. literalinclude:: snippets/decorateur.py
+
+>>> def deco(func):
+...    func.attr = 'decorated'
+...    return func
+...
+>>> @deco
+... def f(): pass
+...
+>>> f.attr
+'decorated'
+>>>
+
+autre exemple : les méthodes statiques
+
+>>> class A(object):
+...   @staticmethod
+...   def my_class_method(cls):
+...      # do stuff here
+         
+         
+métaclasses
+-----------------
+
+>>> class A:
+...   pass
+... 
+>>> type(A)
+<type 'classobj'>
+>>> class B(object): pass
+... 
+>>> type(B)
+<type 'type'>
+>>> help(type)
+
+>>> C = type('C', (), {})
+>>> C
+<class '__main__.C'>
+>>> 
+
+>>> type(object)
+<type 'type'>
+>>> type(type)
+<type 'type'>
+>>> isinstance(type, object)
+True
+>>> isinstance(object, type)
+True
+>>> 
+
+::
+
+  class MaMetaClasse(type):
+    """Exemple d'une métaclasse."""
+    def __new__(metacls, nom, bases, dict):
+        """Création de notre classe."""
+        print("On crée la classe {}".format(nom))
+        return type.__new__(metacls, nom, bases, dict)
+
+  class MaClasse(object):
+    __metaclass__ = MaMetaClasse
+
+
+exemple : forcer l'implémentation d'un singleton avec les métaclasses 
+
+::
+
+  class Singleton(type):
+    instance = None
+    def __call__(cls, *args, **kw):
+        if not cls.instance:
+             cls.instance = super(Singleton, cls).__call__(*args, **kw)
+        return cls.instance
+
+  class ASingleton(object):
+    __metaclass__ = Singleton
+
+    a = ASingleton()
+    b = ASingleton()
+    assert a is b
+    print(a.__class__.__name__, b.__class__.__name__)
+    
+    class BSingleton(object):
+        __metaclass__ = Singleton
+    
+    c = BSingleton()
+    d = BSingleton()
+    assert c is d
+    print(c.__class__.__name__, d.__class__.__name__)
+    assert c is not a
+    

algo/poo/cours/conf.py

@@ -29,7 +29,7 @@ import os
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
 extensions = [
-    'sphinx.ext.pngmath', 'sphinx.ext.ifconfig',
+    'sphinx.ext.pngmath', 'sphinx.ext.ifconfig', 'sphinx.ext.todo',
 ]
 
 # ajout des cours avec solution des exercices ou non
@@ -40,6 +40,7 @@ def setup(app):
 exercice = False
 correction = False
 
+todo_include_todos = True
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
 

algo/poo/cours/index.txt

@@ -6,8 +6,12 @@ Introduction à l'algorithmique
 
     presentation
     fondement
+    mechanism
+    prompt
     langage
     programme
     modularite
     modules
+    classes
+    DesignPatterns
     annexes/index

algo/poo/cours/prompt.txt

@@ -0,0 +1,107 @@
+Interactions avec l'utilisateur
+===============================
+
+les prompts
+--------------
+
+`raw_input` ou `input`
+
+(raw_input renvoie une string, input essayes d'évaluer, soyez prudent...)
+
+>>> from subprocess import call
+>>> filename = input("quel fichier voulez-vous afficher ?\n")
+>>> call("cat " + filename, shell=True)
+
+.. _cmdlabel:
+
+le module :mod:`cmd` et les interpréteurs
+--------------------------------------------
+
+le monde des interpréteur ligne de commande...
+
+Peu après l'âge de bronze vint le temps de l'interpréteur ligne de commande,
+c'est-à-dire quelque chose de plus spécifique que **l'application ligne de commande**,
+ou que l'utilitaire ligne de commande.
+
+
+Un interpréteur ligne de commande est un programme qui :
+
+- est forcément plein texte
+- vous donne un prompt
+- prends toutes ses entrées d'un coup
+- produit une sortie (typiquement des lignes de texte)
+- vous redonne un prompt
+
+Le shell unix est un bon exemple d'interpréteur ligne de commande.
+
+Un utilitaire ligne de commande est un programme unix-like qui prend toutes
+les entrées d'un coup, et qui vous renvoie une sortie d'un coup.
+
+le module :mod:`cmd` : exemple d'utilisation
+
+.. module:: cmd
+    :synopsis: interpréteur ligne de commande
+
+.. literalinclude:: snippets/cli.py
+
+:download:`telecharger cmd <snippets/cli.py>`
+
+::
+
+    >>> from cli import Cli
+    >>> prompt = Cli()
+    >>> prompt.cmdloop()
+    cli (command line interpreter)
+    (type help or ? for commands list)
+    #Prompt> ?
+
+    Documented commands (type help <command>):
+    ==========================================
+    EOF  exit
+
+    Undocumented commands:
+    ======================
+    cmd  help  quit
+
+    #Prompt>
+
+pour ajouter une commande, utiliser simplement l'héritage::
+
+    >>> from cli import Cli
+    >>> class Prompt(Cli):
+    ...   def do_hello(self, line):
+    ...      print "hello %s", line
+    ...
+    >>> prompt = Prompt()
+    >>> prompt.cmdloop()
+    cli (command line interpreter)
+    (type help or ? for commands list)
+    #Prompt> ?
+
+    Documented commands (type help <command>):
+    ==========================================
+    EOF  exit
+
+    Undocumented commands:
+    ======================
+    cmd  hello  help  quit
+
+    #Prompt> hello world
+
+
+.. todo:: faire un petit projet d'interpréteur ligne de commande du jeu C+/C-
+
+lire et écrire dans un fichier
+-------------------------------
+
+les **handle de fichier** (file handles)
+
+
+>>>
+>>> fh = file('test', 'w')
+>>> fh.write('hello world')
+>>> fh.close()
+>>> content = file('test', 'r').read()
+>>> content
+'hello world'
+>>>

algo/poo/cours/snippets/aggregation.py

@@ -0,0 +1,8 @@
+class A:
+    pass
+
+class B:
+    pass
+
+a = A()
+a.b = B()

algo/poo/cours/snippets/cli.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+# -*- coding: utf8 -*-
+"""Command line interpreter
+"""
+import cmd
+
+# ____________________________________________________________
+# this Cli is a model of a basic use of a simple cmd
+class Cli(cmd.Cmd):
+    def __init__(self):
+        cmd.Cmd.__init__(self)
+        self.doc_header = "Documented commands (type help <command>):"
+        self.undoc_header = "Undocumented commands"
+        self.prompt = "#Prompt> "
+        self.intro  = """cli (command line interpreter)
+(type help or ? for commands list)"""
+        self.ruler = "-"
+        
+    def emptyline(self):
+        print "Type 'exit' to finish withe the session or type ? for help."
+
+    def default(self, line):
+        print "unknown command prefix" 
+        print "*** unknown syntax : %s (type 'help' for help for a list of valid commands)"%line
+        self.emptyline()
+
+    def do_exit(self, line):
+        """Exits from the console"""
+        return True
+
+    def do_quit(self, line):
+        return True
+
+    def do_EOF(self, args):
+        """Exit on system end of file character"""
+        return True
+
+# ____________________________________________________________
+# commands pre and post actions
+#    def precmd(self, line):
+#        return line
+#    def postcmd(self, stop, line):
+#        # if there is a problem, just return True : it stops everythings
+#        stop = True
+#        return stop # quit if stop == True
+# ____________________________________________________________
+# program pre and post actions
+#    def preloop(self):
+#        # action for the beginning of the program
+#        pass
+
+#    def postloop(self):
+#        # action for the end of the program
+#        print "exit cli"
+# ____________________________________________________________
+
+class HelloCli(Cli):
+
+    def input_hello(self, line):
+        return line.replace(",", " and ")
+
+    def output_hello(self, result):
+        print result
+
+    def do_hello(self, line):
+        self.output_hello("hello, " + self.input_hello(line))
+        #return False # if you want to stay into the cli
+        return True # if you want to exit
+
+if __name__ == '__main__':
+    prompt = HelloCli()
+    prompt.cmdloop("intro, modifies Cmd.intro")
+

algo/poo/cours/snippets/cmdline.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+
+"""
+Module docstring.
+"""
+
+import sys
+import optparse
+
+def process_command_line(argv):
+    """
+    Return a 2-tuple: (settings object, args list).
+    `argv` is a list of arguments, or `None` for ``sys.argv[1:]``.
+    """
+    if argv is None:
+        argv = sys.argv[1:]
+
+    # initialize the parser object:
+    parser = optparse.OptionParser(
+        formatter=optparse.TitledHelpFormatter(width=78),
+        add_help_option=None)
+
+    # define options here:
+    parser.add_option(      # customized description; put --help last
+        '-h', '--help', action='help',
+        help='Show this help message and exit.')
+
+    settings, args = parser.parse_args(argv)
+
+    # check number of arguments, verify values, etc.:
+    if args:
+        parser.error('program takes no command-line arguments; '
+                     '"%s" ignored.' % (args,))
+
+    # further process settings & args if necessary
+
+    return settings, args
+
+def main(argv=None):
+    settings, args = process_command_line(argv)
+    # application code here, like:
+    # run(settings, args)
+    return 0        # success
+
+if __name__ == '__main__':
+    status = main()
+    sys.exit(status)

algo/poo/cours/snippets/decorateur.py

@@ -0,0 +1,10 @@
+def helloworld(ob):
+    print "Hello world"
+    return ob
+
+@helloworld
+def myfunc():
+    print "my function"
+
+myfunc()
+print myfunc

algo/poo/cours/snippets/heritage.py

@@ -0,0 +1,28 @@
+class Turbo(object):
+    def turbo(self):
+        return "VRRRRROUUUMMM"
+
+class Prix(object):
+    def get_prix(self):
+        raise NotImplementedError
+
+class Voiture(Prix, Turbo):
+    def __init__(self, constructeur, vitesse_max=160):
+        self.constructeur = constructeur
+        self.vitesse_max = vitesse_max
+
+    def roule(self):
+        return "vroummm"
+
+    def signaletique(self):
+        return "constructeur : {0}, vitesse_max {1}".format(self.constructeur,
+            self.vitesse_max)
+
+class DoDoche(Voiture):
+    def get_prix(self):
+        return "4000"
+
+def achete_voiture(voiture):
+    if not hasattr(voiture, "get_prix"):
+        raise TypeError("pas le bon type")
+    return "prix de la voiture: {0} euros".format(voiture.get_prix())

algo/poo/cours/snippets/iterable.py

@@ -0,0 +1,20 @@
+liste = ['blah', 'blih', 'bluh']
+iterateur = liste.__iter__()
+print iterateur.next()
+print iterateur.next()
+print iterateur.next()
+print iterateur.next()
+#Traceback (most recent call last):
+#  File '<stdin>', line 1, in <module>;
+#StopIteration
+
+class Iterateur:
+    i = 0
+    def next(self):
+            if self.i <= 10: raise StopIteration
+            self.i += 1
+            return 2**self.i
+    def __iter__(self): return self
+
+iterateur = Iterateur()
+for i in iterateur: print i

algo/poo/cours/snippets/patrons.py

@@ -0,0 +1,18 @@
+class NotFoundError(Exception): 
+    pass
+
+class MaClasse:
+    pass
+
+class MaClasseDeux:
+    pass
+    
+binding = dict(un=MaClasse, deux=MaClasseDeux)
+
+def ma_factory(key):
+    if key in binding:
+        return binding[key]()
+    else:
+        return NotFoundError("keskece?")
+        
+        

algo/poo/cours/snippets/pystartup

@@ -0,0 +1,28 @@
+# Add auto-completion and a stored history file of commands to your Python
+# interactive interpreter. Requires Python 2.0+, readline. Autocomplete is
+# bound to the Esc key by default (you can change it - see readline docs).
+#
+# Store the file in ~/.pystartup, and set an environment variable to point to
+# it, e.g. "export PYTHONSTARTUP=/max/home/itamar/.pystartup" in bash.
+#
+# Note that PYTHONSTARTUP does *not* expand "~", so you have to put in the full
+# path to your home directory.
+import rlcompleter
+import readline
+readline.parse_and_bind("tab: complete")
+ 
+import os
+histfile = os.path.join(os.environ["HOME"], ".pyhist")
+try:
+    readline.read_history_file(histfile)
+except IOError:
+    pass
+	  
+import atexit
+atexit.register(readline.write_history_file, histfile)
+del os, histfile
+
+# enhanced completion
+#import rlcompleter2
+#rlcompleter2.setup()
+

algo/poo/cours/snippets/sorter.py

@@ -0,0 +1,38 @@
+class Sorter:
+    def sort(self, list):
+        for i in range(len(list) - 1):
+            for j in range(i, len(list)):
+                if self.compareItems(list[i], list[j]):
+                    list[i], list[j] = list[j], list[i]
+
+    def getName(self):
+        return "Trieur de liste"
+
+    def getDescription(self):
+        raise NotImplementedError
+        
+    def compareItems(self, item1, item2):
+        raise NotImplementedError
+
+class AscendantSorter(Sorter):
+    def compareItems(self, item1, item2):
+        return item1 >= item2
+    def getDescription(self):
+        return "Tri par ordre normal"
+    def getName(self):
+        return "Ascendant"
+
+class DescendantSorter(Sorter):
+    def compareItems(self, item1, item2):
+        return item1 <= item2
+    def getDescription(self):
+        return "Tri par ordre inverse"
+
+if __name__ == '__main__':
+    list = ['b', 'e', 'a', 'c', 'z']
+    s = AscendantSorter()
+    s.sort(list)
+    print list
+    s = DescendantSorter()
+    s.sort(list)
+    print list

algo/poo/cours/snippets/specialmethods.py

@@ -0,0 +1,10 @@
+class Zone(object):
+    def __init__(self, name, level=0):
+        self.name = name
+        self.level = level
+
+    def __add__(self, other):
+        return Zone(self.name + other.name, level=self.level+other.level)
+
+    def __cmp__(self, other):
+        return cmp(self.level, other.level)

algo/poo/cours/snippets/wrap.py

@@ -0,0 +1,22 @@
+class Wrap(object):
+    def __init__(self, name, wrap):
+        self.slots = ('_name', '_w')
+        self._name = name or "wrapped_element"
+        self._w = wrap
+
+    def __getattr__(self, name):
+        if name in self.slots:
+            return getattr(self, name)
+        else:
+            return getattr(self._w, name)
+
+#    def get_w(self, name):
+#        return getattr(self._w, name)
+
+#    def set_w(self, name, value):
+#        return setattr(self._w, name, value)
+
+#    _w = property (get_w, set_w)
+
+    def __repr__(self):
+        return "[W_Element %s]"% repr(self._name)