1 (14:31:01) davin.baragiotta: ------------------------------------- DEBUT Atelier Python -------------------------
2 (14:32:19) davin.baragiotta: bonjour à tous
3 (14:32:27) davin.baragiotta: vous devriez avoir lu la page de l'atelier
4 (14:32:28) davin.baragiotta: http://wiki.auf.org/wikiteki/Projet/SemaineTech/2013/Ateliers/Python
5 (14:32:46) davin.baragiotta: le support de présentation est ici :
6 (14:32:47) davin.baragiotta: http://wiki.auf.org/wikiteki/Ateliers/Python/Base/Support
7 (14:32:58) davin.baragiotta: vous devriez avoir 3 fenêtres d'ouvertes :
8 (14:33:03) stefano.amekoudi [stefano.amekoudi@auf.org/CNF Dakar] entered the room.
9 (14:33:07) davin.baragiotta: 1. jabber salon formation (ici) ;)
10 (14:33:14) davin.baragiotta: 2. support de présentation
11 (14:33:17) davin.baragiotta: 3. un terminal
12 (14:33:36) davin.baragiotta: Notre objectif aujourd'hui est de mettre les mains dans Python
13 (14:33:57) davin.baragiotta: y'a 35 personnes dans le salon, mais seulement 5-6 ont dit qu'ils suivaient :
14 (14:34:21) davin.baragiotta: j'espère qu'on pourra aller vite alors pour arriver à l'exercice
15 (14:34:46) davin.baragiotta: cet atelier est le même que celui de l'an dernier (mais je voudrais qu'on fasse exercice)
16 (14:34:58) davin.baragiotta: ok c'est parti
17 (14:35:01) davin.baragiotta: INTRODUCTION
18 (14:35:10) davin.baragiotta: quand on code en Python
19 (14:35:28) davin.baragiotta: on expérimente souvent ce qu'on va coder dans l'interpréteur
20 (14:35:49) davin.baragiotta: et ensuite, on écrit le script final dans un fichier
21 (14:35:52) davin.baragiotta: c'est ce qu'on fera
22 (14:36:09) davin.baragiotta: j'ai mis dans le support de formation, les liens vers la documentation officielle
23 (14:36:28) davin.baragiotta: NOTIONS DE BASE
24 (14:36:35) davin.baragiotta: INTERPRÉTEUR
25 (14:36:45) davin.baragiotta: Python est un langage interprété
26 (14:37:00) davin.baragiotta: on n'a pas besoin de le compiler (comme en Java) pour l'exécuter
27 (14:37:09) davin.baragiotta: c'est pratique pendant le développement
28 (14:37:28) davin.baragiotta: ce qu'on écrit comme code, est interprété par.... l'interpréteur
29 (14:37:41) fred-juvenal.namsionou left the room.
30 (14:37:48) davin.baragiotta: pour lancer l'interpréteur, tapez : "python" dans votre terminal
31 (14:38:00) davin.baragiotta: la version de votre Python s'affiche
32 (14:38:00) shafeek.sumser left the room.
33 (14:38:08) davin.baragiotta: et un "prompt" >>>
34 (14:38:23) davin.baragiotta: moi je préfère travailler avec l'interpréteur ipython
35 (14:38:36) davin.baragiotta: le "i" devant veut dire interactif
36 (14:38:45) davin.baragiotta: cet atelier utilisera ipython
37 (14:38:51) davin.baragiotta: pour l'installer, voir la page de l'atelier
38 (14:38:59) davin.baragiotta:
39 sudo aptitude install ipython
40 (14:39:02) fawaz.tairou [fawaz.tairou@auf.org/Bureau] entered the room.
41 (14:39:26) davin.baragiotta: ipython facilite aussi l'introspection... on va y revenir
42 (14:39:30) davin.baragiotta: SYNTAXE
43 (14:39:35) davin.baragiotta: Python est magnifique
44 (14:39:37) davin.baragiotta: beau
45 (14:39:39) davin.baragiotta: doux
46 (14:39:41) davin.baragiotta: et puissant
47 (14:39:42) davin.baragiotta: :)
48 (14:39:58) davin.baragiotta: la syntaxe participe beaucoup a sa beauté
49 (14:40:17) davin.baragiotta: pour sa puissance... j'aurais dû l'ajouter en intro :
50 (14:40:31) davin.baragiotta: Python est un langage utiliser dans presque tous les domaines imaginables
51 (14:40:42) davin.baragiotta: souvent utiliser comme passerelle entre langages
52 (14:41:01) davin.baragiotta: il est le langage privilégié, de facto, par la communauté universitaire
53 (14:41:17) davin.baragiotta: plein d'outils existent pour faire de la science avec Python (on pourra en parler plus tard)
54 (14:41:27) davin.baragiotta: revenons à la syntaxe
55 (14:41:48) davin.baragiotta: les commentaires se font seulement avec #
56 (14:41:54) davin.baragiotta: pas de /* */ ni de //
57 (14:42:06) davin.baragiotta: les variables? on n'utilise pas de $ devant
58 (14:42:16) davin.baragiotta: à la fin des lignes d'instructions.... pas de ;
59 (14:42:29) davin.baragiotta: aussi.... pas de {} pour les blocs d'instructions
60 (14:42:52) davin.baragiotta: ça c,est possible par un usage obligatoire de l'indentation
61 (14:43:23) davin.baragiotta: donc au final, Python est aéré, donc lisible, donc plus facilement maintenable
62 (14:43:29) davin.baragiotta: ok, assez parlé
63 (14:43:40) davin.baragiotta: jouons ensemble dans l'interpréteur
64 (14:43:44) davin.baragiotta: lancez ipython
65 (14:44:03) davin.baragiotta: davin.baragiotta@u-db:~$ ipython
66 Python 2.6.5 (r265:79063, Oct 1 2012, 22:07:21)
67 Type "copyright", "credits" or "license" for more information.
68
69 IPython 0.10 -- An enhanced Interactive Python.
70 ? -> Introduction and overview of IPython's features.
71 %quickref -> Quick reference.
72 help -> Python's own help system.
73 object? -> Details about 'object'. ?object also works, ?? prints more.
74
75 In [1]:
76
77 (14:44:30) davin.baragiotta: ah oui... dernier truc sur la syntaxe :
78 (14:44:47) davin.baragiotta: Python a une stylistique largement utilisée dans sa communauté
79 (14:44:50) davin.baragiotta: PEP8
80 (14:44:56) davin.baragiotta: http://www.python.org/dev/peps/pep-0008/
81 (14:45:16) davin.baragiotta: PEP = Python Enhencement Proposal (un genre de RFC)
82 (14:45:38) davin.baragiotta: lisez la à temps perdu... ça vous évitera un jour des "ton code n'est pas PEP8" ;)
83 (14:45:50) davin.baragiotta: ok, ipythyon est lancé
84 (14:46:07) davin.baragiotta: on voit la version de Python et la version de ipython
85 (14:46:22) davin.baragiotta: Python vit actuellement avec 2 séries en parallèle
86 (14:46:27) davin.baragiotta: 2.x et 3.x
87 (14:46:40) davin.baragiotta: on travaille encore avec le 2.x même si 3.x = le futur
88 (14:47:02) davin.baragiotta: ok jouons dans interpréteur pour découvrir les variables
89 (14:47:05) davin.baragiotta: VARIABLES
90 (14:47:32) davin.baragiotta: les variables sont des *noms* qui *référencent* des *valeurs*
91 (14:47:45) davin.baragiotta: In [1]: a = 12
92
93 (14:47:59) davin.baragiotta: la variable de nom "a" référence la valeur 12
94 (14:48:20) davin.baragiotta: In [2]: b = a
95
96 In [3]: b
97 Out[3]: 12
98
99 (14:48:47) davin.baragiotta: si on dit que b = a.... Python ne copie pas la valeur 12 dans b...
100 (14:49:00) davin.baragiotta: b point (référence) 12 comme a le faisait
101 (14:49:24) davin.baragiotta: si on utilise une fonction built-in appelé id() qui nous montre l,emplacement en mémoire de la valeur
102 (14:49:29) davin.baragiotta: on voit que c'est la même chose
103 (14:49:42) davin.baragiotta: In [4]: id(a)
104 Out[4]: 168455396
105
106 In [5]: id(b)
107 Out[5]: 168455396
108
109
110 (14:50:08) davin.baragiotta: TYPES
111 (14:50:26) davin.baragiotta: créons ensemble chacun des types de base de Python
112 (14:50:33) davin.baragiotta: n = None
113
114 (14:50:57) davin.baragiotta: None est un type spécial... comme NULL dans les bases de données... représente "rien"
115 (14:51:14) davin.baragiotta: b = True # ou b = False
116 (14:51:27) davin.baragiotta: Boolean... on connait tous
117 (14:51:35) davin.baragiotta: remarquez la syntaxe : faut une majuscule
118 (14:51:50) davin.baragiotta: none, true, false : ça n'existe pas en Python
119 (14:51:58) davin.baragiotta: Python est sensible à la casse
120 (14:52:18) davin.baragiotta: on a pour le numérique des entiers et des floats
121 (14:52:22) davin.baragiotta: i = 15
122 (14:52:26) davin.baragiotta: f = 15.5
123 (14:52:56) davin.baragiotta: dans la vraie vie... ils peuvent se comporter bizarrement dans le calcul (les floats en particuliers)
124 (14:53:34) davin.baragiotta: on va préférer utiliser un type (qui n'est pas "de base") qui s'appelle Decimal (mais il est dans le standard library : il vient avec le langage Python)
125 (14:53:50) davin.baragiotta: finalement on a plusieurs chaînes de caractère
126 (14:54:10) davin.baragiotta: "string"
127 (14:54:14) davin.baragiotta: u"unicode"
128 (14:54:20) davin.baragiotta: r"raw"
129 (14:54:26) davin.baragiotta: noté la lettre mise devant
130 (14:54:57) davin.baragiotta: unicode est pour dire que les caractères de la chaîne sont de l'encodage unicode
131 (14:55:28) davin.baragiotta: raw = caractères bruts, non interprétés... en gros y'a pas de \ pour escaping
132 (14:55:38) davin.baragiotta: concrètement : on utilise ""
133 (14:55:46) davin.baragiotta: sauf pour unicode
134 (14:56:19) davin.baragiotta: finalement on va voir les types de variables de base qui sont des "conteneurs"
135 (14:56:23) davin.baragiotta: es questions avant?
136 (14:57:19) davin.baragiotta: bon on continue
137 (14:57:27) yemen.sayour: (14:57:18) stefano.amekoudi: Question : Dans la vraie vie, quand préférer r"raw" à u"unicode" ?
138 (14:57:57) davin.baragiotta: raw = dans de rares, cas... par exemple pour les regex (expressions régulières)
139 (14:58:11) davin.baragiotta: on le voit dans Django, pour les règles d'URL
140 (14:58:40) davin.baragiotta: (on veut vérifier si l'URL suit un patron régulier... donc on déclare ce patron en "raw")
141 (14:59:33) davin.baragiotta: ok, les conteneurs... le plaisir commence pour vrai, car on monte en complexité
142 (14:59:38) davin.baragiotta: une liste
143 (14:59:41) davin.baragiotta: l = []
144 (14:59:57) davin.baragiotta: c'est une liste ordonnée d'éléments
145 (15:00:04) davin.baragiotta: l = [1,2,3,4]
146 (15:00:12) davin.baragiotta: l = [1,2,2,3,4]
147 (15:00:19) davin.baragiotta: qui peuvent être redondants
148 (15:00:28) davin.baragiotta: (j'ai deux fois 2 ici)
149 (15:00:37) davin.baragiotta: et différents entre eux :
150 (15:00:52) davin.baragiotta: l = [1, 2, 'deux', 3]
151 (15:01:10) davin.baragiotta: (pour être PEP8, mettez une espace après la virgule, c'est plus lisible) ;)
152 (15:01:28) davin.baragiotta: on voit dans mon exemple que j'ai des entiers et un strings
153 (15:01:29) davin.baragiotta: ah oui
154 (15:01:51) davin.baragiotta: string : soit avec simple quote ou double quote : 'string' ou "string"
155 (15:02:19) davin.baragiotta: on a même l'usage de triple pour les chaînes multilignes....
156 (15:02:57) davin.baragiotta: """"Une chaîne multilignes
157 sur deux lignes
158 """
159 (15:03:07) davin.baragiotta: on voit ça dans la documentation : docstring
160 (15:03:28) davin.baragiotta: car en Python, on documente les fonctions (par exemple), dans les fonctions
161 (15:03:40) davin.baragiotta: bon, on a vu grosso modo les listes
162 (15:03:49) davin.baragiotta: voyons les tuples
163 (15:03:51) davin.baragiotta: t = ()
164 (15:04:09) davin.baragiotta: un tuple c'est une liste..... immuable
165 (15:04:12) davin.baragiotta: retenez ça
166 (15:04:39) davin.baragiotta: à quoi ça sert? ben... si tu sais que tu ne modifieras pas la liste, c'est plus rapide (en terme de computation)
167 (15:05:04) davin.baragiotta: un exemple concret ?
168 (15:05:13) davin.baragiotta: des coordonnées... d'une ville disons
169 (15:05:27) davin.baragiotta: montreal = (42, 57)
170 (15:05:48) davin.baragiotta: où 42 = longitude, et l,autre latitude
171 (15:05:59) davin.baragiotta: (exemple fictif hein!)
172 (15:06:26) davin.baragiotta: sachez ce que les tuples existent... car vous le verrez dans le code que vous lirez
173 (15:06:35) davin.baragiotta: vous apprendrez à L'utiliser avec le temps...
174 (15:06:45) davin.baragiotta: autre conteneur :
175 (15:06:47) davin.baragiotta: dictionnaire
176 (15:06:55) davin.baragiotta: d = {}
177 (15:07:22) davin.baragiotta: un dictionnaire est un conteneur d'associations "clé, valeur"
178 (15:07:26) davin.baragiotta: syntaxe :
179 (15:07:47) davin.baragiotta: davin = {'prenom':'Davin', 'nom':'Baragiotta'}
180 (15:07:59) davin.baragiotta: les clés sont uniques...
181 (15:08:08) davin.baragiotta: j'ai pas 2 prénoms...
182 (15:08:37) davin.baragiotta: c'est comme dans un dictionnaire : l'entrée n'est là qu'une fois (même si elle a plusieurs définitions ;) )
183 (15:08:58) davin.baragiotta: les valeurs peuvent évidemment être de n'importe quel type
184 (15:09:12) davin.baragiotta: la`'Davin' et 'Baragiotta' sont des strings...
185 (15:09:21) davin.baragiotta: mais j'aurais pu mettre 'age':38
186 (15:09:27) davin.baragiotta: (ouaip... depuis hier!)
187 (15:09:49) davin.baragiotta: les clés, elles aussi doivent être de plusieurs type
188 (15:09:52) davin.baragiotta: mais
189 (15:10:11) davin.baragiotta: pour qu'on puisse vérifier si sont unique, elles doivent être immuables
190 (15:10:25) davin.baragiotta: tiens essayons ceci :
191 (15:10:36) davin.baragiotta: d = {15:'Davin'}
192 (15:10:57) davin.baragiotta: ça marche
193 (15:11:24) davin.baragiotta: j'ai utilisé l'entier 15 pour index
194 (15:11:26) davin.baragiotta: ok
195 (15:11:32) davin.baragiotta: dernier type
196 (15:11:35) davin.baragiotta: les ensembles
197 (15:11:37) davin.baragiotta: j'aime!
198 (15:11:49) davin.baragiotta: en anglais, un ensemble est un "set"
199 (15:12:34) davin.baragiotta: comme en mathématique... un ensemble est non-ordonné... et ses éléments sont uniques
200 (15:13:00) davin.baragiotta: ex. en Français... si on dit l'ensemble des Techs de l'AUF... c'est débile de me citer deux fois!
201 (15:13:15) davin.baragiotta: créons une liste avec des éléments redondants
202 (15:13:29) davin.baragiotta: l = [1, 2, 2, 3, 3, 3]
203 (15:13:57) davin.baragiotta: faisons maintenant un ensemble de cette liste
204 (15:13:59) davin.baragiotta: set(l)
205 (15:14:23) davin.baragiotta: In [11]: l = [1, 2, 2, 3, 3, 3]
206
207 In [12]: set(l)
208 Out[12]: set([1, 2, 3])
209
210 (15:14:44) davin.baragiotta: voilà! on a donc les éléments mais non redondants...
211 (15:15:05) davin.baragiotta: on finit maintenant la théorie sur les types
212 (15:15:19) davin.baragiotta: un truc pas mal en Python
213 (15:15:31) davin.baragiotta: c'est un peu de la syntaxe : le unpacking
214 (15:16:03) davin.baragiotta: ex.; montreal est un tuple de coordonnées, disons x et y
215 (15:16:10) davin.baragiotta: In [13]: montreal = (42, 57)
216 (15:16:27) davin.baragiotta: je peux "unpacker" la variable montreal dans 2 variables x et y
217 (15:16:38) davin.baragiotta: In [14]: x, y = montreal
218 (15:16:48) davin.baragiotta:
219 In [15]: x
220 Out[15]: 42
221
222 In [16]: y
223 Out[16]: 57
224
225 (15:16:51) davin.baragiotta: joli, non?
226 (15:17:24) davin.baragiotta: Python permet aussi de déclarer en une ligne que plusieurs variables ont la même valeur
227 (15:17:33) davin.baragiotta: a, b, c = 14
228 (15:17:44) davin.baragiotta: crotte non!
229 (15:17:54) davin.baragiotta: In [17]: a, b, c = 14
230 ---------------------------------------------------------------------------
231
232
233 /net/nfs-authnss.b.ca.auf/home/davin.baragiotta/<ipython console> in <module>()
234
235 (15:18:37) davin.baragiotta: j'ai eu une erreur de type, car justement... Python pensait que je voulais "unpacker" 14...
236 (15:18:39) davin.baragiotta: TypeError: 'int' object is not iterable
237
238 (15:18:46) davin.baragiotta: en essayent d'itérer
239 (15:18:53) davin.baragiotta: faut donc écrire :
240 (15:19:00) davin.baragiotta: a, b, c = 14, 14, 14
241 (15:19:05) davin.baragiotta: bon, moins intéressant ;)
242 (15:19:27) davin.baragiotta: finalement.... sachez que Python est fortement typé
243 (15:19:40) davin.baragiotta: on sait que Python est interprété (pas compilé)
244 (15:20:04) davin.baragiotta: mais il aussi fortement typé : on peut pas faire n'importe quoi avec les variables
245 (15:20:23) davin.baragiotta: ex.:
246 'Davin' + 5
247 (15:20:37) davin.baragiotta:
248 In [18]: 'Davin' + 5
249 ---------------------------------------------------------------------------
250
251
252 /net/nfs-authnss.b.ca.auf/home/davin.baragiotta/<ipython console> in <module>()
253
254 TypeError: cannot concatenate 'str' and 'int' objects
255
256 (15:20:47) davin.baragiotta: On a encore un TypeError
257 (15:20:52) davin.baragiotta: explicite en plus
258 (15:21:15) davin.baragiotta: je ne peux pas concaténer un 'str' (string) et nu 'int' (integer... un entier)
259 (15:21:52) davin.baragiotta: en PHP, ça aurait marché... PHP aurait dit "aaaah, je comprends que tu veux concaténer un string avec un entier"
260 (15:22:12) davin.baragiotta: en Python, pour faire ça... on va transtyper (changer de type) nous même les variables
261 (15:22:30) davin.baragiotta: pour ça, on a des focntions dédiées :
262 (15:22:54) davin.baragiotta: In [20]: cinq = str(5)
263
264 (15:23:08) davin.baragiotta: In [21]: type(cinq)
265 Out[21]: <type 'str'>
266
267
268 (15:23:53) davin.baragiotta: en utilisant la fonction built-in str() on peut créer des chaînes
269 (15:24:05) davin.baragiotta: str() peut servir à initialiser une chaîne
270 (15:24:17) davin.baragiotta: s = str()
271 (15:24:25) davin.baragiotta: mais ce n'est pas vraiment utile
272 (15:24:33) davin.baragiotta: car Python est dynamique :
273 (15:24:59) davin.baragiotta: pas besoin de "déclarer" les variables avec leurs types... comme en Java
274 (15:25:19) davin.baragiotta: donc Python est interprété, fortement typé et dynamique
275 (15:25:35) davin.baragiotta: ok avançons pour être dynaiqmue aussi! on veut coder!
276 (15:25:55) davin.baragiotta: BUILT-IN : FONCTIONS ET STRUCTURE DU LANGAGE
277 (15:26:09) davin.baragiotta: suivez moi dans le support de présentation
278 (15:26:37) davin.baragiotta: on voit là le lien vers la documentation officielle où sont listées toutes les fonctions "built-in"
279 (15:26:51) davin.baragiotta: c,est à dire des fonctions qui viennet avec le langage : qu'on n,a pas beosin de coder
280 (15:27:02) davin.baragiotta: ... il n'y en n'a pas des masses, comparé à PHP
281 (15:27:18) davin.baragiotta: c'est que Python est un langage Orienté-objet...
282 (15:27:36) davin.baragiotta: et il offre plein d'objets au lieu de fournir plein de fonctions ;)
283 (15:28:01) davin.baragiotta: je passe rapidement sur les fonctions built-in... on les verra au fur et à mesure
284 (15:28:32) davin.baragiotta: mais type() permet de tester le type d'un objet
285 (15:28:45) davin.baragiotta: (on l'a utilisé sur la variable "cinq" plus haut)
286 (15:29:07) davin.baragiotta: len() permet de compter la longeur d'éléments... très utile
287 (15:29:09) davin.baragiotta: exemple :
288 (15:29:26) davin.baragiotta:
289 In [23]: l = [1,2,3,4,4,4]
290
291 In [24]: len(l)
292 Out[24]: 6
293
294 (15:29:35) davin.baragiotta: on a 6 éléments dans cette liste
295 (15:30:27) davin.baragiotta: ok, dégourdissez-vous un instant... je vais remplir mon café et je vous fais découvrir la toute puissance de l'orienté objet et de l'introspection
296 (15:30:36) davin.baragiotta: ce qui fait que Python nous permet de travailler vite
297 (15:30:38) davin.baragiotta: très vite
298 (15:30:46) davin.baragiotta: (café, je reviens)
299 (15:32:39) davin.baragiotta: (de retour)
300 (15:32:58) davin.baragiotta: OBJETS ET NAMESPACE
301 (15:33:12) davin.baragiotta: qu'est qu'un objet... au sens de "orienté-objet"
302 (15:33:23) davin.baragiotta: c'est rien d'autre qu'une structure d'information
303 (15:33:48) davin.baragiotta: un peu comme le dictionnaire Python, tiens...
304 (15:34:14) davin.baragiotta: un objet stocke "sur lui"... ou "derrière lui" son information
305 (15:34:35) davin.baragiotta: moi, j'ai un nom et un prénom
306 (15:35:13) davin.baragiotta: si j'étais un objet informatique... ce sera mes "attributs"... des variables qui me sont attachées
307 (15:35:25) davin.baragiotta: attributs = variables d'un objet
308 (15:35:59) davin.baragiotta: aussi, dans certain cas, on va associer des instructions de traitement de l'info propre à un objet sur l'objet même
309 (15:36:22) davin.baragiotta: on va mettre des "méthodes" qui sont des fonctions "sur l'objet"...
310 (15:36:30) davin.baragiotta: méthodes = fonctions d'un objet
311 (15:36:57) davin.baragiotta: ex.: si on veut mon âge... on pourrait mettre un attribut : age = 38
312 (15:37:05) davin.baragiotta: mais c'est nul car l'âge varie dans le temps
313 (15:37:23) davin.baragiotta: on va créer une méthode qui va retourner l'age en fonction de la date de naissance
314 (15:37:48) davin.baragiotta: age()
315 (15:38:18) davin.baragiotta: si on avait un objet personne... on aurait :
316 * nom
317 * prenom
318 * date_naissance
319 * age()
320 (15:38:48) davin.baragiotta: qui serait SUR l'objet.... ou DERRIÈRE L,objet... on accède à ces infos en passant par l'objet
321 (15:38:55) davin.baragiotta: d'où l'idée de NAMESPACE
322 (15:39:08) davin.baragiotta: les variables ou attributs ont des noms : prenom, nom
323 (15:39:18) davin.baragiotta: les fonctions ou méthodes ont des noms : age
324 (15:39:40) davin.baragiotta: (même si pour les appeler, les exécuter, on met des ()... leur nom n'a pas de ()
325 (15:39:48) davin.baragiotta: exécuter : age()
326 (15:39:56) davin.baragiotta: nom : age
327 (15:40:24) davin.baragiotta: pour accéder aux noms, Python utilise la syntaxe avec des points...
328 (15:40:40) davin.baragiotta: objet.attribut (ex.: personne.nom )
329 (15:40:55) davin.baragiotta: objet.methode (personne.age)
330 (15:41:30) davin.baragiotta: mais laissons l'exemple fictif... pour explorer les OBJETS... en parcourant leur NAMESPACE... via l' INTROSPECTION
331 (15:41:40) davin.baragiotta: questions?
332 (15:42:19) davin.baragiotta: Question : un NAMESPACE doit etre consideré comme une classe ?
333 (15:42:30) davin.baragiotta: Réponse NON
334 (15:42:48) davin.baragiotta: ce sont des noms derrières des noms... tout simplement... mais c'est possible
335 (15:43:32) davin.baragiotta: car en orienté-objet... l'objet a un nom... il a des attributs attachés à lui qui ont des noms... des méthodes attachées à lui qui ont des noms
336 (15:43:37) davin.baragiotta: et oui
337 (15:43:46) davin.baragiotta: les objets sont créés par des "classes"
338 (15:43:59) davin.baragiotta: class Personne():
339 (15:44:32) davin.baragiotta: y'a un lien entre "noms" et "classe" mais pas direct
340 (15:44:40) davin.baragiotta: INTROSPECTION
341 (15:44:54) davin.baragiotta: prenons une chaine de caractère
342 (15:45:10) davin.baragiotta: In [25]: nom = "Davin Baragiotta"
343 (15:45:21) davin.baragiotta: on sait maintenant qu'on a ici un type string
344 (15:45:34) davin.baragiotta: mais la question qui tue : on veut faire quoi... dans la vie... avec des strings?
345 (15:46:02) davin.baragiotta: ehu... peut-être les fusionner avec d'autres strings?... les concaténer
346 (15:46:07) davin.baragiotta: les tronquer?
347 (15:46:12) davin.baragiotta: les mettre en majuscule
348 (15:46:27) davin.baragiotta: ... bref toutes sortes de choses qu'on ne fait QUE sur les chaînes de caractères
349 (15:46:39) davin.baragiotta: mais j'ai pas envie de coder tout ça moi!
350 (15:46:57) davin.baragiotta: Python offre ces méthodes de traitement des string... sur les strings même
351 (15:47:19) davin.baragiotta: pour les découvrir, avec ipython on introspecte (on interroge) la string comme suit :
352 (15:47:31) davin.baragiotta: nom. (suivi d'un tab)
353 (15:47:46) davin.baragiotta: In [26]: nom.
354 nom.__add__ nom.__repr__ nom.istitle
355 nom.__class__ nom.__rmod__ nom.isupper
356 nom.__contains__ nom.__rmul__ nom.join
357 nom.__delattr__ nom.__setattr__ nom.ljust
358 nom.__doc__ nom.__sizeof__ nom.lower
359 nom.__eq__ nom.__str__ nom.lstrip
360 nom.__format__ nom.__subclasshook__ nom.partition
361 nom.__ge__ nom._formatter_field_name_split nom.replace
362 nom.__getattribute__ nom._formatter_parser nom.rfind
363 nom.__getitem__ nom.capitalize nom.rindex
364 nom.__getnewargs__ nom.center nom.rjust
365 nom.__getslice__ nom.count nom.rpartition
366 nom.__gt__ nom.decode nom.rsplit
367 nom.__hash__ nom.encode nom.rstrip
368 nom.__init__ nom.endswith nom.split
369 nom.__le__ nom.expandtabs nom.splitlines
370 nom.__len__ nom.find nom.startswith
371 nom.__lt__ nom.format nom.strip
372 --More--
373
374
375 (15:48:09) davin.baragiotta: vous êtes puissants maintenant, jeunes padawan! ;)
376 (15:48:26) progfou [jean-christophe.andre@auf.org/Gajim] entered the room.
377 (15:48:32) davin.baragiotta: et oui... on voit les NOMS des atttributs et méthodes sur les string
378 (15:48:37) davin.baragiotta: ok, lisons
379 (15:48:54) davin.baragiotta: vous voulez tout en minuscule, supposons...
380 (15:49:03) davin.baragiotta: qu'est-ce qu'on pourrait prendre?
381 (15:49:21) davin.baragiotta: hmmm.... on lit les noms disponibles sur (derrière) la string
382 (15:49:27) davin.baragiotta: ah? lower?
383 (15:49:56) davin.baragiotta: pour lire la doc d'une méthode... avec ipython
384 (15:50:03) davin.baragiotta: on utilise le ?
385 (15:50:08) davin.baragiotta: nom.lower?
386 (15:50:36) davin.baragiotta: (ah... si vous êtes encore coincés avec le "More" de l'introspection des noms... appuyez sur Q pour Quit)
387 (15:50:47) davin.baragiotta:
388 In [26]: nom.lower?
389 Type: builtin_function_or_method
390 Base Class: <type 'builtin_function_or_method'>
391 String Form: <built-in method lower of str object at 0xa465890>
392 Namespace: Interactive
393 Docstring:
394 S.lower() -> string
395
396 Return a copy of the string S converted to lowercase.
397
398 (15:51:07) davin.baragiotta: ipython nous donne l'info sur le nom "lower"
399 (15:51:49) davin.baragiotta: tiens... "lower" est de type "built-in method".... ok, donc on peut l'appeler (en ajoutant parenthèse)
400 (15:52:05) davin.baragiotta: on lit la docstring : Return a copy of the string S converted to lowercase.
401 (15:52:12) davin.baragiotta: parfait ça!
402 (15:52:18) davin.baragiotta: nom.lower
403 (15:52:31) davin.baragiotta:
404 In [27]: nom.lower
405 Out[27]: <built-in method lower of str object at 0xa465890>
406
407 (15:52:42) davin.baragiotta: ah... on a oublié les parenthèses...
408 (15:52:49) davin.baragiotta: on l'a pas appelé donc
409 (15:52:51) davin.baragiotta: nom.lower()
410 (15:53:07) davin.baragiotta:
411 In [27]: nom.lower
412 Out[27]: <built-in method lower of str object at 0xa465890>
413
414 (15:53:10) davin.baragiotta: ta-dammm
415 (15:53:34) davin.baragiotta: vous venez, avec ipython... de découvrir ce qu'un string pouvait faire...
416 (15:53:55) davin.baragiotta: vous avez cherchez, lu la doc.... et expérimenté directement dans l'interpréteur
417 (15:54:04) davin.baragiotta: c'est fort ça...
418 (15:54:47) davin.baragiotta: (on peut introspecter avec interpréteur normal python avec les focntions : dir() pour avoir les noms... et help() pour lire la doc )
419 (15:55:12) davin.baragiotta: vous savez explorer seuls maintenant
420 (15:55:32) davin.baragiotta: nous reste donc à s'amuser un peu avec le reste du langage (autre que les types)
421 (15:55:38) davin.baragiotta: CONTENEURS
422 (15:55:53) davin.baragiotta: on a vu que les liste, tuple et dictionnaire sont des conteneurs
423 (15:56:22) davin.baragiotta: on peut imbriquer les conteneurs dans des conteneurs
424 (15:56:28) davin.baragiotta: exemple de liste imbriquées
425 (15:56:35) davin.baragiotta: l = [[1,2,3],[4,'salut',6],[7,8,9]]
426 (15:56:51) davin.baragiotta: la liste [1, 2, 3] est le premier élément de ma liste l
427 (15:57:15) davin.baragiotta: aussi... on peut accéder aux éléments des conteurs en utilisant la notation d'index :
428 (15:57:26) davin.baragiotta: l[0] : retourne le premier élément
429 (15:57:40) davin.baragiotta:
430 In [29]: l = [[1,2,3],[4,'salut',6],[7,8,9]]
431
432 In [30]: l[0]
433 Out[30]: [1, 2, 3]
434 (15:57:56) davin.baragiotta: finalement, une notion propre à Python... le slicing
435 (15:58:05) davin.baragiotta: une slice en angals c'est une "tranche"
436 (15:58:11) davin.baragiotta: anglais
437 (15:58:33) davin.baragiotta: on peut extraire une tranche de liste avec une extension de la notation d'index
438 (15:58:37) davin.baragiotta: l[0:2]
439 (15:58:50) davin.baragiotta:
440 In [31]: l[0:2]
441 Out[31]: [[1, 2, 3], [4, 'salut', 6]]
442
443 (15:59:13) davin.baragiotta: ça se lit : à partir du premier élément (0), donne m'en 2...
444 (15:59:14) davin.baragiotta: voilà
445 (15:59:35) davin.baragiotta: questions sur introspection et conteneurs?
446 (15:59:58) davin.baragiotta: on continue
447 (16:00:45) davin.baragiotta: je passe rapidement sur la syntaxe des ITÉRATIONS et COMPARAISONS
448 (16:00:51) davin.baragiotta: car c'est très intuitif
449 (16:01:09) davin.baragiotta: il faut remarquer par contre la beauté de la syntaxe : les blocs n'ont pas de {}
450 (16:01:20) davin.baragiotta: faut utiliser l'indentation
451 (16:01:53) davin.baragiotta: selon PEP8, utilisez 4 espaces pour indenter vos lignes de codes (PAS de tabs)
452 (16:02:33) davin.baragiotta: codons une petite boucle for
453 (16:02:43) davin.baragiotta:
454 for i in range(2012, 2016):
455 (16:02:45) davin.baragiotta: ach
456 (16:02:52) davin.baragiotta:
457 for i in range(2012, 2016):
458 print i
459 (16:03:47) davin.baragiotta: ici on utilise range, une fonction built-in pour générer des nombres entre 2 bornes
460 (16:03:56) davin.baragiotta: (dernière exclue)
461 (16:04:33) davin.baragiotta:
462 In [33]: for i in range(2012, 2016):
463 ....: print i
464 ....:
465 ....:
466 2012
467 2013
468 2014
469 2015
470
471
472 (16:04:49) davin.baragiotta: voilà... pas {}.... pas de ; pour fin d'instruction... que du beau
473 (16:05:16) davin.baragiotta: COMPARAISONS : je vous laisse expérimenter... mais je vous montre un truc cool : in, not in
474 (16:05:44) davin.baragiotta: créez une liste avec des éléments
475 (16:05:54) davin.baragiotta: on va voir si une valeur est dans la liste avec "in"
476 (16:06:19) davin.baragiotta:
477 In [34]: l = [1, 2, 3, 4]
478
479 In [35]: 3 in l
480 Out[35]: True
481
482 In [36]: 5 in l
483 Out[36]: False
484
485 (16:06:30) davin.baragiotta: ahahaha! si c,est pas magnifique ça!
486 (16:06:40) davin.baragiotta: utile pour créer de beaux conditionnels!
487 (16:06:45) davin.baragiotta: CONDITIONNELS
488 (16:07:03) davin.baragiotta: pas grand chose à dire, sinon qu'on a un elif (pour enchainer des conditions)
489 (16:07:11) davin.baragiotta: encore une fois : pas de {}, pas de ;
490 (16:07:36) davin.baragiotta: vérifier dans le document de présentation, section CONDITIONNEL
491 (16:07:40) davin.baragiotta: http://wiki.auf.org/wikiteki/Ateliers/Python/Base/Support
492 (16:07:53) davin.baragiotta: voilà... questions, remarques jusqu'ici?
493 (16:08:23) davin.baragiotta: progfou me faisait remarquer une erreur sur les slices
494 (16:08:29) davin.baragiotta: l[0:2]
495 (16:08:31) progfou: une remarque sur ce point :
496 [08:58:36] davin.baragiotta: l[0:2]
497 [08:59:12] davin.baragiotta: ça se lit : à partir du premier élément (0), donne m'en 2...
498 => en fait ça se lit : à partir du premier élément (0) jusqu'au 3ème (2) exclu
499 => c'est vraiment une notion de « tranche » (de cette position ci à cette position là) par opposition à la notion de sous-chaîne (substring) dans la plupart des autres langages (à partir de là, n éléments)
500 (16:08:45) davin.baragiotta: voilà
501 (16:08:58) davin.baragiotta: donc 2 veut dire... "jusqu'à 3è position"
502 (16:09:03) davin.baragiotta: testez, vous verrez
503 (16:09:36) davin.baragiotta: pour finir, je saute FICHIERS, FORMATTAGE DE CHAÎNE, COMPRÉHENSION DE LISTE
504 (16:09:43) davin.baragiotta: essayons de faire un script
505 (16:10:04) davin.baragiotta: créez un fichier texte, nommé, disons : script.py
506 (16:10:43) davin.baragiotta: coder le for qu'on a vu, par exemple
507 (16:11:03) davin.baragiotta:
508 for i in range(2012, 2016): print i
509 (16:11:13) davin.baragiotta: pour exécuter le script
510 (16:11:28) davin.baragiotta: dans ipython : simplement écrire :
511 run script
512 (16:11:58) davin.baragiotta: (pour peu que soit dans répertoire courant de interpréteur... sinon donner le path)
513 (16:12:11) davin.baragiotta: avec python normal :
514 $ python script.py
515 (16:12:18) davin.baragiotta: (path au besoin, évidemment)
516 (16:12:48) davin.baragiotta: voilà... votre script est interprété... la boucle for exécutée... on print des années (ce sont des entiers, en fait)
517 (16:12:54) davin.baragiotta: ce script n'est pas utile...
518 (16:13:06) davin.baragiotta: mais vous pouvez expérimentez dans interpréteur
519 (16:13:25) davin.baragiotta: pour trouver ce qui utile avec les objets existants (types de base)
520 (16:13:26) davin.baragiotta: ou
521 (16:13:38) davin.baragiotta: coder vos traitements... notamment vos fonctions
522 (16:13:51) davin.baragiotta: je passe la partie FONCTIONS par manque de temps
523 (16:14:08) davin.baragiotta: on pourra continuer dans un labo, si des gens sont intéressés
524 (16:14:21) davin.baragiotta: finalement, je ne peut pas partir sans parler des IMPORT
525 (16:14:43) davin.baragiotta: jusqu'ici, on a vu des notions "built-in"... qui viennent avec le langage :
526 (16:14:50) davin.baragiotta: on lance interpéteur... c'est là
527 (16:15:07) davin.baragiotta: mais y,a plein de fonctionnalités qui viennent aussi avec le langage, qu'il faut importer au besoin
528 (16:15:23) davin.baragiotta: exemple : des types pour les dates, l'heure
529 (16:15:29) davin.baragiotta: c'est dans datetime
530 (16:15:48) davin.baragiotta: lisez la doc de la "standard library" Python
531 (16:16:05) davin.baragiotta: les modules "qui viennent avec Python... mais qui faut importer pour les utiliser
532 (16:16:38) davin.baragiotta: on peut aussi importer des modules tiers, qui ne viennent pas avec Python... mais faut d'abord les installer sur le système :
533 (16:16:41) davin.baragiotta: ex.: Django
534 (16:16:49) davin.baragiotta: import django
535 (16:16:54) davin.baragiotta: c'est un autre atelier... ;)
536 (16:17:01) davin.baragiotta: des questions?
537 (16:17:24) davin.baragiotta: CONCLUSION
538 (16:17:30) davin.baragiotta: Python est simple et puissant
539 (16:17:32) davin.baragiotta: vraiment
540 (16:17:44) davin.baragiotta: pas juste pour l'AUF... pour tous les domaines
541 (16:18:18) davin.baragiotta: l'apprendre vous donne la liberté de coder
542 (16:18:46) davin.baragiotta: c'est la Semaine Tech : ceux intéressés à aller plus loin ou approfondir : faites moi signe, on se monte un labo
543 (16:19:11) davin.baragiotta: ---------------------------------- FIN Atelier Python -----------------------------