formations/python/formation/specialmethods.txt

230 lines
4.9 KiB
Plaintext
Raw Normal View History

2013-01-08 11:15:45 +01:00
Programmation python courante
================================
.. _namespaces:
2013-01-08 15:24:39 +01:00
Les espaces de nommage
2013-01-08 11:15:45 +01:00
-----------------------
Packages et modules::
package/
__init__.py
module1.py
subpackage/
__init__.py
module2.py
2013-01-08 15:24:39 +01:00
À utilser pour organiser votre projet.
Permet de minimiser les risques de conflits de nom.
Permet de diminuer les entrées dans le :envvar:`PYTHONPATH`.
2013-01-08 11:15:45 +01:00
::
import package.module1
from package.subpackage import module2
from package.subpackage.module2 import name
- le fichier `__init__.py`
- `reload(module)` au prompt
- dangereux : l'import "*", utiliser l'attribut spécial `__all__` pour l'import
sélectif
::
from os import *
2013-01-08 15:24:39 +01:00
Lancer un module en tant que script :
2013-01-08 11:15:45 +01:00
::
if __name__ == "__main__":
main()
2013-01-08 15:24:39 +01:00
Organisation modulaire :
2013-01-08 11:15:45 +01:00
2013-01-08 15:24:39 +01:00
- construire des composants élémentaires ;
- combiner ces composants ;
2013-01-08 11:15:45 +01:00
- utiliser une structure pyramidale : les composants sont les éléments de
composants plus complexes.
2013-01-08 15:24:39 +01:00
- découplage de l'ensemble en composants indépendants (gros programmes réalisables) ;
- donner de la structure (rendre les gros programmes compréhensibles) ;
- spécifier les liens entre les composants (rendre les programmes maintenables) ;
- identifier les sous-composants indépendants (rendre les programmes réutilisables) ;
- forcer l'abstraction (augmenter la sureté du programme).
2013-01-08 11:15:45 +01:00
Les méthodes spéciales
-----------------------
2013-01-08 15:24:39 +01:00
Méthodes spéciales correspondant aux interfaces des types de bases :
2013-01-08 11:15:45 +01:00
.. function:: __init__(self, *args, **kwargs)
le constructeur de l'instance d'objet
.. function:: __add__(self, other)
correspond à la notation `+`
exemple :
.. literalinclude:: snippets/specialmethods.py
>>> from specialmethods import *
>>> z = Zone("titi", 10)
>>> z2 = Zone("tutu", 40)
>>> z > z2
False
>>> z + z2
<specialmethods.Zone object at 0x7f02d95fb190>
>>> z3 = z + z2
>>> z3.name
'tititutu'
>>> z3.level
50
>>>
Attributs et accesseurs
---------------------------
python est un langage à attributs, c'est-à-dire que le protocole d'accès
aux attributs est règlable.
>>> class C(object):
... classattr = "a class attribute"
...
>>> cobj = C()
>>> cobj.classattr
'a class attribute'
>>> cobj.insattr = "an instance attribute"
>>> cobj.insattr
'an instance attribute'
>>> C.__dict__['classattr']
'a class attribute'
>>> cobj.__dict__['insattr']
'an instance attribute'
2013-01-08 15:24:39 +01:00
Les attributs ne sont pas systématiquement encapsulés en python.
2013-01-08 11:15:45 +01:00
2013-01-08 15:24:39 +01:00
Pour contrôler l'accès aux attributs, on utilise les méthodes spéciales::
2013-01-08 11:15:45 +01:00
__getattr__(self, name)
__setattr__(self, name, value)
class AnObject(object):
......
def __setattr__(self, name, val):
if name == 'src': #do something
# this will assign the real object.name,
#despite __setattr__
self.__dict__[name]=val
def __getattr__(self, name):
# ...
try:
func = getattr(obj, "method")
except AttributeError:
... deal with missing method ...
else:
result = func(args)
func = getattr(obj, "method", None)
if callable(func):
func(args)
.. todo:: émulation de defaultdict
Dict with a default value
--------------------------
2013-01-08 15:24:39 +01:00
Il est possible d'hériter des types de base
2013-01-08 11:15:45 +01:00
>>> a = dict.defaultdict(default=0)
>>> a
{}
>>> a[1] = 2
>>> print a
{1: 2}
>>> a[0]
0
>>> a.keys()
[1]
>>> a["machin"]
0
::
class defaultdict(dict):
def __init__(self, default=None):
dict.__init__(self)
self.default = default
def __getitem__(self, key):
try:
return dict.__getitem__(self, key)
except KeyError:
return self.default
def __getitem__(self, key):
if key in self:
return dict.__getitem__(self, key)
else:
return self.default
def get(self, key, *args):
if not args:
args = (self.default,)
return dict.get(self, key, *args)
- un **attribut** spécial : `__slots__`
permet de fixer les attributs possibles d'une classe
::
>>> class Bar(object):
... __slots__ = ("a","b","c")
...
>>> b = Bar()
>>> b.a = "toto"
>>> b.a
'toto'
>>> b.d = "titi"
Traceback (most recent call last):
File "<stdin>", line 1, in ?
AttributeError: 'Bar' object has no attribute 'd'
>>> class Point(object):
... __slots__ = 'x', 'y'
...
>>> p = Point()
>>> p.x = 2
>>> p.y = 3
>>> p.z = 4
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute 'z'
>>>
- notation `|` et notation `>`
::
class Test:
nombre = 1
def __or__(self, other):
return self.nombre + other.nombre
def __lshift__(self, other):
self.nombre = self.nombre + other.nombre
t1 = Test()
t2 = Test()
t2.nombre = 2
print t1 | t2
t1 << t2
print t1.nombre