formations/python/formation/structures.txt

306 lines
4.9 KiB
Plaintext
Raw Normal View History

2013-01-08 11:15:45 +01:00
Structures de contrôle et fonctions
====================================
- tests
>>> if "a":
... print "a"
...
a
>>> if "":
... print "hell"
...
>>> a = 2
>>> if a == 1:
... print "un"
... else:
... print "deux"
...
deux
>>>
.. important:: les types de base ont tous une valeur booléenne
- itérations
>>> for i in range(10):
... print i
...
0
1
2
3
4
5
6
7
8
9
>>>
>>> l = range(10)
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
- tant que
>>> i = 10
>>> while i != 0:
... print i
... i = i -1
...
10
9
8
7
6
5
4
3
2
1
>>>
2013-01-08 15:24:39 +01:00
Fonctions
2013-01-08 11:15:45 +01:00
-----------
>>> def blabla(x):
... """fonction qui printe"""
... print x
...
>>>
2013-01-08 15:24:39 +01:00
Il n'y a que des fonctions (et pas de procédures):
2013-01-08 11:15:45 +01:00
>>> def ma_func(x):
... "écrit quelque chose dans un fichier"
...
>>> ma_func("a")
>>> print ma_func("a")
None
>>>
est équivalent à :
>>> def ma_func(x):
... "écrit quelque chose dans un fichier"
... return None
- arité d'une fonction:
- paramètre non nommé
- paramètre nommé
>>> def ma_fonction(*args, **kwargs):
... print "arguments : ", str(args)
... print "argumments nommés", str(kwargs)
...
>>> ma_fonction("toto", "titi", tutu=2, tata=3)
arguments : ('toto', 'titi')
argumments nommés {'tata': 3, 'tutu': 2}
>>>
- signature d'une fonction : ça peut renvoyer n'importe quoi (tout ce qu'on veut)
:term:`return` ou :term:`yield` ?
.. glossary::
yield
permet de renvoyer le résultat d'une fonction en plusieurs étape
à l'aide d'un générateur
return
résultat d'une fonction
>>> def ma_fonction():
... for i in range(10):
... yield i
...
>>> for i in ma_fonction():
... print i
...
0
1
2
3
4
5
6
7
8
9
>>>
- espaces de nommage à l'intérieur d'une fonction :
>>> def toto(x):
... print vars()
...
>>> toto("sdfsdf")
{'x': 'sdfsdf'}
>>> class A(object):pass
...
>>> a = A()
>>> a.a = "titi"
>>> a.b = "toto"
>>> vars(a)
{'a': 'titi', 'b': 'toto'}
2013-01-08 15:24:39 +01:00
Puisque tout est objet en python, ``vars(mon_objet)`` est équivalent à
2013-01-08 11:15:45 +01:00
``mon_objet.__dict__``
- générateurs et compréhension de liste
2013-01-08 15:24:39 +01:00
Les compréhensions de listes permettent de générer de nouvelles listes
2013-01-08 11:15:45 +01:00
exemple :
>>> [ 2*i for i in range(10)]
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>>>
>>> [x for x in range(10) if x>5]
[6, 7, 8, 9]
>>>
>>> [(i, j) for i in range(2,5) for j in range (4,8)]
[(2, 4), (2, 5), (2, 6), (2, 7), (3, 4), (3, 5), (3, 6), (3, 7), (4, 4), (4, 5), (4, 6), (4, 7)]
>>>
2013-01-08 15:24:39 +01:00
Les expressions générateurs
2013-01-08 11:15:45 +01:00
>>> expr = (2*i for i in range(10))
>>> expr
<generator object <genexpr> at 0x7ff9efa77cd0>
>>> for e in expr:
... print e
...
0
2
4
6
8
10
12
14
16
18
>>>
2013-01-08 15:24:39 +01:00
Le polymorphisme paramétrique
2013-01-08 11:15:45 +01:00
-----------------------------
2013-01-08 15:24:39 +01:00
Polymorphisme exemple de contexte :
2013-01-08 11:15:45 +01:00
la fonction print
>>> print 1
1
>>> print "1"
1
.. todo:: `print 1` et `print "1"` renvoient le même résultat. Pourquoi ?
2013-01-08 15:24:39 +01:00
La programmation par exceptions
2013-01-08 11:15:45 +01:00
-------------------------------------
>>> def function_raise(x):
... if not type(x) == int:
... raise TypeError("Pas le bon type")
... else:
... return x + 1
...
>>> try:
... e = function_raise("une string")
... except TypeError, e:
... print e
...
Pas le bon type
>>
.. important:: règle du Samouraï : une fonction doit renvoyer le résultat escompté
ou bien lever une exception
2013-01-08 15:24:39 +01:00
Programmation objet
2013-01-08 11:15:45 +01:00
--------------------
- la programmation objet définit des classes
- 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
>>> class A:
... pass
...
>>> a = A()
>>> a.a = 2
>>> def function(x):
... print x
...
>>> a.f = function
>>> a.f("hello")
hello
>>>
- instance de classe : on peut créer des objets à partir d'un type "classe"
(une classe est instanciable)
- définition d'une classe :
2013-01-08 15:24:39 +01:00
Méthode classique :
2013-01-08 11:15:45 +01:00
>>> class A:
... pass
...
2013-01-08 15:24:39 +01:00
Méthode dynamique (la fonction :func:`type` est ici un **constructeur** :
2013-01-08 11:15:45 +01:00
>>> type("A", (), {})
<class '__main__.A'>
>>> A = type("A", (), {})
>>> a = A()
>>> type(a)
<class '__main__.A'>
2013-01-08 15:24:39 +01:00
Types et classe
2013-01-08 11:15:45 +01:00
~~~~~~~~~~~~~~~~~
2013-01-08 15:24:39 +01:00
Affichage d'une calculette, il faut créer un type `Touche`
2013-01-08 11:15:45 +01:00
qui contient deux désignations : `Chiffre` et `operation`::
type operation = Plus | Moins | Divise
type touche = Chiffre of int | Memoire | Op of operation
2013-01-08 15:24:39 +01:00
Soit on définit un type touche, soit on ne définit pas ce type::
2013-01-08 11:15:45 +01:00
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
.. todo:: tout hérite de la classe `object`
>>> object
<type 'object'>
>>> type(object)
<type 'type'>
>>> type(type)
<type 'type'>
>>> type(type(type))
<type 'type'>
>>> isinstance(type, object)
True
>>> isinstance(object, object)
True
**conclusion** : en python un type et une classe c'est la même chose. Une classe
est un type standard !