=== ARCHIVE ATELIER Python === {{{#!highlight irc (14:31:01) davin.baragiotta: ------------------------------------- DEBUT Atelier Python ------------------------- (14:32:19) davin.baragiotta: bonjour à tous (14:32:27) davin.baragiotta: vous devriez avoir lu la page de l'atelier (14:32:28) davin.baragiotta: http://wiki.auf.org/wikiteki/Projet/SemaineTech/2013/Ateliers/Python (14:32:46) davin.baragiotta: le support de présentation est ici : (14:32:47) davin.baragiotta: http://wiki.auf.org/wikiteki/Ateliers/Python/Base/Support (14:32:58) davin.baragiotta: vous devriez avoir 3 fenêtres d'ouvertes : (14:33:03) stefano.amekoudi [stefano.amekoudi@auf.org/CNF Dakar] entered the room. (14:33:07) davin.baragiotta: 1. jabber salon formation (ici) ;) (14:33:14) davin.baragiotta: 2. support de présentation (14:33:17) davin.baragiotta: 3. un terminal (14:33:36) davin.baragiotta: Notre objectif aujourd'hui est de mettre les mains dans Python (14:33:57) davin.baragiotta: y'a 35 personnes dans le salon, mais seulement 5-6 ont dit qu'ils suivaient : (14:34:21) davin.baragiotta: j'espère qu'on pourra aller vite alors pour arriver à l'exercice (14:34:46) davin.baragiotta: cet atelier est le même que celui de l'an dernier (mais je voudrais qu'on fasse exercice) (14:34:58) davin.baragiotta: ok c'est parti (14:35:01) davin.baragiotta: INTRODUCTION (14:35:10) davin.baragiotta: quand on code en Python (14:35:28) davin.baragiotta: on expérimente souvent ce qu'on va coder dans l'interpréteur (14:35:49) davin.baragiotta: et ensuite, on écrit le script final dans un fichier (14:35:52) davin.baragiotta: c'est ce qu'on fera (14:36:09) davin.baragiotta: j'ai mis dans le support de formation, les liens vers la documentation officielle (14:36:28) davin.baragiotta: NOTIONS DE BASE (14:36:35) davin.baragiotta: INTERPRÉTEUR (14:36:45) davin.baragiotta: Python est un langage interprété (14:37:00) davin.baragiotta: on n'a pas besoin de le compiler (comme en Java) pour l'exécuter (14:37:09) davin.baragiotta: c'est pratique pendant le développement (14:37:28) davin.baragiotta: ce qu'on écrit comme code, est interprété par.... l'interpréteur (14:37:41) fred-juvenal.namsionou left the room. (14:37:48) davin.baragiotta: pour lancer l'interpréteur, tapez : "python" dans votre terminal (14:38:00) davin.baragiotta: la version de votre Python s'affiche (14:38:00) shafeek.sumser left the room. (14:38:08) davin.baragiotta: et un "prompt" >>> (14:38:23) davin.baragiotta: moi je préfère travailler avec l'interpréteur ipython (14:38:36) davin.baragiotta: le "i" devant veut dire interactif (14:38:45) davin.baragiotta: cet atelier utilisera ipython (14:38:51) davin.baragiotta: pour l'installer, voir la page de l'atelier (14:38:59) davin.baragiotta: sudo aptitude install ipython (14:39:02) fawaz.tairou [fawaz.tairou@auf.org/Bureau] entered the room. (14:39:26) davin.baragiotta: ipython facilite aussi l'introspection... on va y revenir (14:39:30) davin.baragiotta: SYNTAXE (14:39:35) davin.baragiotta: Python est magnifique (14:39:37) davin.baragiotta: beau (14:39:39) davin.baragiotta: doux (14:39:41) davin.baragiotta: et puissant (14:39:42) davin.baragiotta: :) (14:39:58) davin.baragiotta: la syntaxe participe beaucoup a sa beauté (14:40:17) davin.baragiotta: pour sa puissance... j'aurais dû l'ajouter en intro : (14:40:31) davin.baragiotta: Python est un langage utiliser dans presque tous les domaines imaginables (14:40:42) davin.baragiotta: souvent utiliser comme passerelle entre langages (14:41:01) davin.baragiotta: il est le langage privilégié, de facto, par la communauté universitaire (14:41:17) davin.baragiotta: plein d'outils existent pour faire de la science avec Python (on pourra en parler plus tard) (14:41:27) davin.baragiotta: revenons à la syntaxe (14:41:48) davin.baragiotta: les commentaires se font seulement avec # (14:41:54) davin.baragiotta: pas de /* */ ni de // (14:42:06) davin.baragiotta: les variables? on n'utilise pas de $ devant (14:42:16) davin.baragiotta: à la fin des lignes d'instructions.... pas de ; (14:42:29) davin.baragiotta: aussi.... pas de {} pour les blocs d'instructions (14:42:52) davin.baragiotta: ça c,est possible par un usage obligatoire de l'indentation (14:43:23) davin.baragiotta: donc au final, Python est aéré, donc lisible, donc plus facilement maintenable (14:43:29) davin.baragiotta: ok, assez parlé (14:43:40) davin.baragiotta: jouons ensemble dans l'interpréteur (14:43:44) davin.baragiotta: lancez ipython (14:44:03) davin.baragiotta: davin.baragiotta@u-db:~$ ipython Python 2.6.5 (r265:79063, Oct 1 2012, 22:07:21) Type "copyright", "credits" or "license" for more information. IPython 0.10 -- An enhanced Interactive Python. ? -> Introduction and overview of IPython's features. %quickref -> Quick reference. help -> Python's own help system. object? -> Details about 'object'. ?object also works, ?? prints more. In [1]: (14:44:30) davin.baragiotta: ah oui... dernier truc sur la syntaxe : (14:44:47) davin.baragiotta: Python a une stylistique largement utilisée dans sa communauté (14:44:50) davin.baragiotta: PEP8 (14:44:56) davin.baragiotta: http://www.python.org/dev/peps/pep-0008/ (14:45:16) davin.baragiotta: PEP = Python Enhencement Proposal (un genre de RFC) (14:45:38) davin.baragiotta: lisez la à temps perdu... ça vous évitera un jour des "ton code n'est pas PEP8" ;) (14:45:50) davin.baragiotta: ok, ipythyon est lancé (14:46:07) davin.baragiotta: on voit la version de Python et la version de ipython (14:46:22) davin.baragiotta: Python vit actuellement avec 2 séries en parallèle (14:46:27) davin.baragiotta: 2.x et 3.x (14:46:40) davin.baragiotta: on travaille encore avec le 2.x même si 3.x = le futur (14:47:02) davin.baragiotta: ok jouons dans interpréteur pour découvrir les variables (14:47:05) davin.baragiotta: VARIABLES (14:47:32) davin.baragiotta: les variables sont des *noms* qui *référencent* des *valeurs* (14:47:45) davin.baragiotta: In [1]: a = 12 (14:47:59) davin.baragiotta: la variable de nom "a" référence la valeur 12 (14:48:20) davin.baragiotta: In [2]: b = a In [3]: b Out[3]: 12 (14:48:47) davin.baragiotta: si on dit que b = a.... Python ne copie pas la valeur 12 dans b... (14:49:00) davin.baragiotta: b point (référence) 12 comme a le faisait (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 (14:49:29) davin.baragiotta: on voit que c'est la même chose (14:49:42) davin.baragiotta: In [4]: id(a) Out[4]: 168455396 In [5]: id(b) Out[5]: 168455396 (14:50:08) davin.baragiotta: TYPES (14:50:26) davin.baragiotta: créons ensemble chacun des types de base de Python (14:50:33) davin.baragiotta: n = None (14:50:57) davin.baragiotta: None est un type spécial... comme NULL dans les bases de données... représente "rien" (14:51:14) davin.baragiotta: b = True # ou b = False (14:51:27) davin.baragiotta: Boolean... on connait tous (14:51:35) davin.baragiotta: remarquez la syntaxe : faut une majuscule (14:51:50) davin.baragiotta: none, true, false : ça n'existe pas en Python (14:51:58) davin.baragiotta: Python est sensible à la casse (14:52:18) davin.baragiotta: on a pour le numérique des entiers et des floats (14:52:22) davin.baragiotta: i = 15 (14:52:26) davin.baragiotta: f = 15.5 (14:52:56) davin.baragiotta: dans la vraie vie... ils peuvent se comporter bizarrement dans le calcul (les floats en particuliers) (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) (14:53:50) davin.baragiotta: finalement on a plusieurs chaînes de caractère (14:54:10) davin.baragiotta: "string" (14:54:14) davin.baragiotta: u"unicode" (14:54:20) davin.baragiotta: r"raw" (14:54:26) davin.baragiotta: noté la lettre mise devant (14:54:57) davin.baragiotta: unicode est pour dire que les caractères de la chaîne sont de l'encodage unicode (14:55:28) davin.baragiotta: raw = caractères bruts, non interprétés... en gros y'a pas de \ pour escaping (14:55:38) davin.baragiotta: concrètement : on utilise "" (14:55:46) davin.baragiotta: sauf pour unicode (14:56:19) davin.baragiotta: finalement on va voir les types de variables de base qui sont des "conteneurs" (14:56:23) davin.baragiotta: es questions avant? (14:57:19) davin.baragiotta: bon on continue (14:57:27) yemen.sayour: (14:57:18) stefano.amekoudi: Question : Dans la vraie vie, quand préférer r"raw" à u"unicode" ? (14:57:57) davin.baragiotta: raw = dans de rares, cas... par exemple pour les regex (expressions régulières) (14:58:11) davin.baragiotta: on le voit dans Django, pour les règles d'URL (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") (14:59:33) davin.baragiotta: ok, les conteneurs... le plaisir commence pour vrai, car on monte en complexité (14:59:38) davin.baragiotta: une liste (14:59:41) davin.baragiotta: l = [] (14:59:57) davin.baragiotta: c'est une liste ordonnée d'éléments (15:00:04) davin.baragiotta: l = [1,2,3,4] (15:00:12) davin.baragiotta: l = [1,2,2,3,4] (15:00:19) davin.baragiotta: qui peuvent être redondants (15:00:28) davin.baragiotta: (j'ai deux fois 2 ici) (15:00:37) davin.baragiotta: et différents entre eux : (15:00:52) davin.baragiotta: l = [1, 2, 'deux', 3] (15:01:10) davin.baragiotta: (pour être PEP8, mettez une espace après la virgule, c'est plus lisible) ;) (15:01:28) davin.baragiotta: on voit dans mon exemple que j'ai des entiers et un strings (15:01:29) davin.baragiotta: ah oui (15:01:51) davin.baragiotta: string : soit avec simple quote ou double quote : 'string' ou "string" (15:02:19) davin.baragiotta: on a même l'usage de triple pour les chaînes multilignes.... (15:02:57) davin.baragiotta: """"Une chaîne multilignes sur deux lignes """ (15:03:07) davin.baragiotta: on voit ça dans la documentation : docstring (15:03:28) davin.baragiotta: car en Python, on documente les fonctions (par exemple), dans les fonctions (15:03:40) davin.baragiotta: bon, on a vu grosso modo les listes (15:03:49) davin.baragiotta: voyons les tuples (15:03:51) davin.baragiotta: t = () (15:04:09) davin.baragiotta: un tuple c'est une liste..... immuable (15:04:12) davin.baragiotta: retenez ça (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) (15:05:04) davin.baragiotta: un exemple concret ? (15:05:13) davin.baragiotta: des coordonnées... d'une ville disons (15:05:27) davin.baragiotta: montreal = (42, 57) (15:05:48) davin.baragiotta: où 42 = longitude, et l,autre latitude (15:05:59) davin.baragiotta: (exemple fictif hein!) (15:06:26) davin.baragiotta: sachez ce que les tuples existent... car vous le verrez dans le code que vous lirez (15:06:35) davin.baragiotta: vous apprendrez à L'utiliser avec le temps... (15:06:45) davin.baragiotta: autre conteneur : (15:06:47) davin.baragiotta: dictionnaire (15:06:55) davin.baragiotta: d = {} (15:07:22) davin.baragiotta: un dictionnaire est un conteneur d'associations "clé, valeur" (15:07:26) davin.baragiotta: syntaxe : (15:07:47) davin.baragiotta: davin = {'prenom':'Davin', 'nom':'Baragiotta'} (15:07:59) davin.baragiotta: les clés sont uniques... (15:08:08) davin.baragiotta: j'ai pas 2 prénoms... (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 ;) ) (15:08:58) davin.baragiotta: les valeurs peuvent évidemment être de n'importe quel type (15:09:12) davin.baragiotta: la`'Davin' et 'Baragiotta' sont des strings... (15:09:21) davin.baragiotta: mais j'aurais pu mettre 'age':38 (15:09:27) davin.baragiotta: (ouaip... depuis hier!) (15:09:49) davin.baragiotta: les clés, elles aussi doivent être de plusieurs type (15:09:52) davin.baragiotta: mais (15:10:11) davin.baragiotta: pour qu'on puisse vérifier si sont unique, elles doivent être immuables (15:10:25) davin.baragiotta: tiens essayons ceci : (15:10:36) davin.baragiotta: d = {15:'Davin'} (15:10:57) davin.baragiotta: ça marche (15:11:24) davin.baragiotta: j'ai utilisé l'entier 15 pour index (15:11:26) davin.baragiotta: ok (15:11:32) davin.baragiotta: dernier type (15:11:35) davin.baragiotta: les ensembles (15:11:37) davin.baragiotta: j'aime! (15:11:49) davin.baragiotta: en anglais, un ensemble est un "set" (15:12:34) davin.baragiotta: comme en mathématique... un ensemble est non-ordonné... et ses éléments sont uniques (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! (15:13:15) davin.baragiotta: créons une liste avec des éléments redondants (15:13:29) davin.baragiotta: l = [1, 2, 2, 3, 3, 3] (15:13:57) davin.baragiotta: faisons maintenant un ensemble de cette liste (15:13:59) davin.baragiotta: set(l) (15:14:23) davin.baragiotta: In [11]: l = [1, 2, 2, 3, 3, 3] In [12]: set(l) Out[12]: set([1, 2, 3]) (15:14:44) davin.baragiotta: voilà! on a donc les éléments mais non redondants... (15:15:05) davin.baragiotta: on finit maintenant la théorie sur les types (15:15:19) davin.baragiotta: un truc pas mal en Python (15:15:31) davin.baragiotta: c'est un peu de la syntaxe : le unpacking (15:16:03) davin.baragiotta: ex.; montreal est un tuple de coordonnées, disons x et y (15:16:10) davin.baragiotta: In [13]: montreal = (42, 57) (15:16:27) davin.baragiotta: je peux "unpacker" la variable montreal dans 2 variables x et y (15:16:38) davin.baragiotta: In [14]: x, y = montreal (15:16:48) davin.baragiotta: In [15]: x Out[15]: 42 In [16]: y Out[16]: 57 (15:16:51) davin.baragiotta: joli, non? (15:17:24) davin.baragiotta: Python permet aussi de déclarer en une ligne que plusieurs variables ont la même valeur (15:17:33) davin.baragiotta: a, b, c = 14 (15:17:44) davin.baragiotta: crotte non! (15:17:54) davin.baragiotta: In [17]: a, b, c = 14 --------------------------------------------------------------------------- TypeError Traceback (most recent call last) /net/nfs-authnss.b.ca.auf/home/davin.baragiotta/ in () (15:18:37) davin.baragiotta: j'ai eu une erreur de type, car justement... Python pensait que je voulais "unpacker" 14... (15:18:39) davin.baragiotta: TypeError: 'int' object is not iterable (15:18:46) davin.baragiotta: en essayent d'itérer (15:18:53) davin.baragiotta: faut donc écrire : (15:19:00) davin.baragiotta: a, b, c = 14, 14, 14 (15:19:05) davin.baragiotta: bon, moins intéressant ;) (15:19:27) davin.baragiotta: finalement.... sachez que Python est fortement typé (15:19:40) davin.baragiotta: on sait que Python est interprété (pas compilé) (15:20:04) davin.baragiotta: mais il aussi fortement typé : on peut pas faire n'importe quoi avec les variables (15:20:23) davin.baragiotta: ex.: 'Davin' + 5 (15:20:37) davin.baragiotta: In [18]: 'Davin' + 5 --------------------------------------------------------------------------- TypeError Traceback (most recent call last) /net/nfs-authnss.b.ca.auf/home/davin.baragiotta/ in () TypeError: cannot concatenate 'str' and 'int' objects (15:20:47) davin.baragiotta: On a encore un TypeError (15:20:52) davin.baragiotta: explicite en plus (15:21:15) davin.baragiotta: je ne peux pas concaténer un 'str' (string) et nu 'int' (integer... un entier) (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" (15:22:12) davin.baragiotta: en Python, pour faire ça... on va transtyper (changer de type) nous même les variables (15:22:30) davin.baragiotta: pour ça, on a des focntions dédiées : (15:22:54) davin.baragiotta: In [20]: cinq = str(5) (15:23:08) davin.baragiotta: In [21]: type(cinq) Out[21]: (15:23:53) davin.baragiotta: en utilisant la fonction built-in str() on peut créer des chaînes (15:24:05) davin.baragiotta: str() peut servir à initialiser une chaîne (15:24:17) davin.baragiotta: s = str() (15:24:25) davin.baragiotta: mais ce n'est pas vraiment utile (15:24:33) davin.baragiotta: car Python est dynamique : (15:24:59) davin.baragiotta: pas besoin de "déclarer" les variables avec leurs types... comme en Java (15:25:19) davin.baragiotta: donc Python est interprété, fortement typé et dynamique (15:25:35) davin.baragiotta: ok avançons pour être dynaiqmue aussi! on veut coder! (15:25:55) davin.baragiotta: BUILT-IN : FONCTIONS ET STRUCTURE DU LANGAGE (15:26:09) davin.baragiotta: suivez moi dans le support de présentation (15:26:37) davin.baragiotta: on voit là le lien vers la documentation officielle où sont listées toutes les fonctions "built-in" (15:26:51) davin.baragiotta: c,est à dire des fonctions qui viennet avec le langage : qu'on n,a pas beosin de coder (15:27:02) davin.baragiotta: ... il n'y en n'a pas des masses, comparé à PHP (15:27:18) davin.baragiotta: c'est que Python est un langage Orienté-objet... (15:27:36) davin.baragiotta: et il offre plein d'objets au lieu de fournir plein de fonctions ;) (15:28:01) davin.baragiotta: je passe rapidement sur les fonctions built-in... on les verra au fur et à mesure (15:28:32) davin.baragiotta: mais type() permet de tester le type d'un objet (15:28:45) davin.baragiotta: (on l'a utilisé sur la variable "cinq" plus haut) (15:29:07) davin.baragiotta: len() permet de compter la longeur d'éléments... très utile (15:29:09) davin.baragiotta: exemple : (15:29:26) davin.baragiotta: In [23]: l = [1,2,3,4,4,4] In [24]: len(l) Out[24]: 6 (15:29:35) davin.baragiotta: on a 6 éléments dans cette liste (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 (15:30:36) davin.baragiotta: ce qui fait que Python nous permet de travailler vite (15:30:38) davin.baragiotta: très vite (15:30:46) davin.baragiotta: (café, je reviens) (15:32:39) davin.baragiotta: (de retour) (15:32:58) davin.baragiotta: OBJETS ET NAMESPACE (15:33:12) davin.baragiotta: qu'est qu'un objet... au sens de "orienté-objet" (15:33:23) davin.baragiotta: c'est rien d'autre qu'une structure d'information (15:33:48) davin.baragiotta: un peu comme le dictionnaire Python, tiens... (15:34:14) davin.baragiotta: un objet stocke "sur lui"... ou "derrière lui" son information (15:34:35) davin.baragiotta: moi, j'ai un nom et un prénom (15:35:13) davin.baragiotta: si j'étais un objet informatique... ce sera mes "attributs"... des variables qui me sont attachées (15:35:25) davin.baragiotta: attributs = variables d'un objet (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 (15:36:22) davin.baragiotta: on va mettre des "méthodes" qui sont des fonctions "sur l'objet"... (15:36:30) davin.baragiotta: méthodes = fonctions d'un objet (15:36:57) davin.baragiotta: ex.: si on veut mon âge... on pourrait mettre un attribut : age = 38 (15:37:05) davin.baragiotta: mais c'est nul car l'âge varie dans le temps (15:37:23) davin.baragiotta: on va créer une méthode qui va retourner l'age en fonction de la date de naissance (15:37:48) davin.baragiotta: age() (15:38:18) davin.baragiotta: si on avait un objet personne... on aurait : * nom * prenom * date_naissance * age() (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 (15:38:55) davin.baragiotta: d'où l'idée de NAMESPACE (15:39:08) davin.baragiotta: les variables ou attributs ont des noms : prenom, nom (15:39:18) davin.baragiotta: les fonctions ou méthodes ont des noms : age (15:39:40) davin.baragiotta: (même si pour les appeler, les exécuter, on met des ()... leur nom n'a pas de () (15:39:48) davin.baragiotta: exécuter : age() (15:39:56) davin.baragiotta: nom : age (15:40:24) davin.baragiotta: pour accéder aux noms, Python utilise la syntaxe avec des points... (15:40:40) davin.baragiotta: objet.attribut (ex.: personne.nom ) (15:40:55) davin.baragiotta: objet.methode (personne.age) (15:41:30) davin.baragiotta: mais laissons l'exemple fictif... pour explorer les OBJETS... en parcourant leur NAMESPACE... via l' INTROSPECTION (15:41:40) davin.baragiotta: questions? (15:42:19) davin.baragiotta: Question : un NAMESPACE doit etre consideré comme une classe ? (15:42:30) davin.baragiotta: Réponse NON (15:42:48) davin.baragiotta: ce sont des noms derrières des noms... tout simplement... mais c'est possible (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 (15:43:37) davin.baragiotta: et oui (15:43:46) davin.baragiotta: les objets sont créés par des "classes" (15:43:59) davin.baragiotta: class Personne(): (15:44:32) davin.baragiotta: y'a un lien entre "noms" et "classe" mais pas direct (15:44:40) davin.baragiotta: INTROSPECTION (15:44:54) davin.baragiotta: prenons une chaine de caractère (15:45:10) davin.baragiotta: In [25]: nom = "Davin Baragiotta" (15:45:21) davin.baragiotta: on sait maintenant qu'on a ici un type string (15:45:34) davin.baragiotta: mais la question qui tue : on veut faire quoi... dans la vie... avec des strings? (15:46:02) davin.baragiotta: ehu... peut-être les fusionner avec d'autres strings?... les concaténer (15:46:07) davin.baragiotta: les tronquer? (15:46:12) davin.baragiotta: les mettre en majuscule (15:46:27) davin.baragiotta: ... bref toutes sortes de choses qu'on ne fait QUE sur les chaînes de caractères (15:46:39) davin.baragiotta: mais j'ai pas envie de coder tout ça moi! (15:46:57) davin.baragiotta: Python offre ces méthodes de traitement des string... sur les strings même (15:47:19) davin.baragiotta: pour les découvrir, avec ipython on introspecte (on interroge) la string comme suit : (15:47:31) davin.baragiotta: nom. (suivi d'un tab) (15:47:46) davin.baragiotta: In [26]: nom. nom.__add__ nom.__repr__ nom.istitle nom.__class__ nom.__rmod__ nom.isupper nom.__contains__ nom.__rmul__ nom.join nom.__delattr__ nom.__setattr__ nom.ljust nom.__doc__ nom.__sizeof__ nom.lower nom.__eq__ nom.__str__ nom.lstrip nom.__format__ nom.__subclasshook__ nom.partition nom.__ge__ nom._formatter_field_name_split nom.replace nom.__getattribute__ nom._formatter_parser nom.rfind nom.__getitem__ nom.capitalize nom.rindex nom.__getnewargs__ nom.center nom.rjust nom.__getslice__ nom.count nom.rpartition nom.__gt__ nom.decode nom.rsplit nom.__hash__ nom.encode nom.rstrip nom.__init__ nom.endswith nom.split nom.__le__ nom.expandtabs nom.splitlines nom.__len__ nom.find nom.startswith nom.__lt__ nom.format nom.strip --More-- (15:47:52) davin.baragiotta: Ta-daaaaaaaaaaaaaam! (15:48:09) davin.baragiotta: vous êtes puissants maintenant, jeunes padawan! ;) (15:48:26) progfou [jean-christophe.andre@auf.org/Gajim] entered the room. (15:48:32) davin.baragiotta: et oui... on voit les NOMS des atttributs et méthodes sur les string (15:48:37) davin.baragiotta: ok, lisons (15:48:54) davin.baragiotta: vous voulez tout en minuscule, supposons... (15:49:03) davin.baragiotta: qu'est-ce qu'on pourrait prendre? (15:49:21) davin.baragiotta: hmmm.... on lit les noms disponibles sur (derrière) la string (15:49:27) davin.baragiotta: ah? lower? (15:49:56) davin.baragiotta: pour lire la doc d'une méthode... avec ipython (15:50:03) davin.baragiotta: on utilise le ? (15:50:08) davin.baragiotta: nom.lower? (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) (15:50:47) davin.baragiotta: In [26]: nom.lower? Type: builtin_function_or_method Base Class: String Form: Namespace: Interactive Docstring: S.lower() -> string Return a copy of the string S converted to lowercase. (15:51:07) davin.baragiotta: ipython nous donne l'info sur le nom "lower" (15:51:49) davin.baragiotta: tiens... "lower" est de type "built-in method".... ok, donc on peut l'appeler (en ajoutant parenthèse) (15:52:05) davin.baragiotta: on lit la docstring : Return a copy of the string S converted to lowercase. (15:52:12) davin.baragiotta: parfait ça! (15:52:18) davin.baragiotta: nom.lower (15:52:31) davin.baragiotta: In [27]: nom.lower Out[27]: (15:52:42) davin.baragiotta: ah... on a oublié les parenthèses... (15:52:49) davin.baragiotta: on l'a pas appelé donc (15:52:51) davin.baragiotta: nom.lower() (15:53:07) davin.baragiotta: In [27]: nom.lower Out[27]: (15:53:10) davin.baragiotta: ta-dammm (15:53:34) davin.baragiotta: vous venez, avec ipython... de découvrir ce qu'un string pouvait faire... (15:53:55) davin.baragiotta: vous avez cherchez, lu la doc.... et expérimenté directement dans l'interpréteur (15:54:04) davin.baragiotta: c'est fort ça... (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 ) (15:55:12) davin.baragiotta: vous savez explorer seuls maintenant (15:55:32) davin.baragiotta: nous reste donc à s'amuser un peu avec le reste du langage (autre que les types) (15:55:38) davin.baragiotta: CONTENEURS (15:55:53) davin.baragiotta: on a vu que les liste, tuple et dictionnaire sont des conteneurs (15:56:22) davin.baragiotta: on peut imbriquer les conteneurs dans des conteneurs (15:56:28) davin.baragiotta: exemple de liste imbriquées (15:56:35) davin.baragiotta: l = [[1,2,3],[4,'salut',6],[7,8,9]] (15:56:51) davin.baragiotta: la liste [1, 2, 3] est le premier élément de ma liste l (15:57:15) davin.baragiotta: aussi... on peut accéder aux éléments des conteurs en utilisant la notation d'index : (15:57:26) davin.baragiotta: l[0] : retourne le premier élément (15:57:40) davin.baragiotta: In [29]: l = [[1,2,3],[4,'salut',6],[7,8,9]] In [30]: l[0] Out[30]: [1, 2, 3] (15:57:56) davin.baragiotta: finalement, une notion propre à Python... le slicing (15:58:05) davin.baragiotta: une slice en angals c'est une "tranche" (15:58:11) davin.baragiotta: anglais (15:58:33) davin.baragiotta: on peut extraire une tranche de liste avec une extension de la notation d'index (15:58:37) davin.baragiotta: l[0:2] (15:58:50) davin.baragiotta: In [31]: l[0:2] Out[31]: [[1, 2, 3], [4, 'salut', 6]] (15:59:13) davin.baragiotta: ça se lit : à partir du premier élément (0), donne m'en 2... (15:59:14) davin.baragiotta: voilà (15:59:35) davin.baragiotta: questions sur introspection et conteneurs? (15:59:58) davin.baragiotta: on continue (16:00:45) davin.baragiotta: je passe rapidement sur la syntaxe des ITÉRATIONS et COMPARAISONS (16:00:51) davin.baragiotta: car c'est très intuitif (16:01:09) davin.baragiotta: il faut remarquer par contre la beauté de la syntaxe : les blocs n'ont pas de {} (16:01:20) davin.baragiotta: faut utiliser l'indentation (16:01:53) davin.baragiotta: selon PEP8, utilisez 4 espaces pour indenter vos lignes de codes (PAS de tabs) (16:02:33) davin.baragiotta: codons une petite boucle for (16:02:43) davin.baragiotta: for i in range(2012, 2016): (16:02:45) davin.baragiotta: ach (16:02:52) davin.baragiotta: for i in range(2012, 2016): print i (16:03:47) davin.baragiotta: ici on utilise range, une fonction built-in pour générer des nombres entre 2 bornes (16:03:56) davin.baragiotta: (dernière exclue) (16:04:33) davin.baragiotta: In [33]: for i in range(2012, 2016): ....: print i ....: ....: 2012 2013 2014 2015 (16:04:49) davin.baragiotta: voilà... pas {}.... pas de ; pour fin d'instruction... que du beau (16:05:16) davin.baragiotta: COMPARAISONS : je vous laisse expérimenter... mais je vous montre un truc cool : in, not in (16:05:44) davin.baragiotta: créez une liste avec des éléments (16:05:54) davin.baragiotta: on va voir si une valeur est dans la liste avec "in" (16:06:19) davin.baragiotta: In [34]: l = [1, 2, 3, 4] In [35]: 3 in l Out[35]: True In [36]: 5 in l Out[36]: False (16:06:30) davin.baragiotta: ahahaha! si c,est pas magnifique ça! (16:06:40) davin.baragiotta: utile pour créer de beaux conditionnels! (16:06:45) davin.baragiotta: CONDITIONNELS (16:07:03) davin.baragiotta: pas grand chose à dire, sinon qu'on a un elif (pour enchainer des conditions) (16:07:11) davin.baragiotta: encore une fois : pas de {}, pas de ; (16:07:36) davin.baragiotta: vérifier dans le document de présentation, section CONDITIONNEL (16:07:40) davin.baragiotta: http://wiki.auf.org/wikiteki/Ateliers/Python/Base/Support (16:07:53) davin.baragiotta: voilà... questions, remarques jusqu'ici? (16:08:23) davin.baragiotta: progfou me faisait remarquer une erreur sur les slices (16:08:29) davin.baragiotta: l[0:2] (16:08:31) progfou: une remarque sur ce point : ‎[08:58:36] ‎davin.baragiotta‎: l[0:2] ‎‎[08:59:12] ‎davin.baragiotta‎: ça se lit : à partir du premier élément (0), donne m'en 2... => en fait ça se lit : à partir du premier élément (0) jusqu'au 3ème (2) exclu => 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) (16:08:45) davin.baragiotta: voilà (16:08:58) davin.baragiotta: donc 2 veut dire... "jusqu'à 3è position" (16:09:03) davin.baragiotta: testez, vous verrez (16:09:36) davin.baragiotta: pour finir, je saute FICHIERS, FORMATTAGE DE CHAÎNE, COMPRÉHENSION DE LISTE (16:09:43) davin.baragiotta: essayons de faire un script (16:10:04) davin.baragiotta: créez un fichier texte, nommé, disons : script.py (16:10:43) davin.baragiotta: coder le for qu'on a vu, par exemple (16:11:03) davin.baragiotta: for i in range(2012, 2016): print i (16:11:13) davin.baragiotta: pour exécuter le script (16:11:28) davin.baragiotta: dans ipython : simplement écrire : run script (16:11:58) davin.baragiotta: (pour peu que soit dans répertoire courant de interpréteur... sinon donner le path) (16:12:11) davin.baragiotta: avec python normal : $ python script.py (16:12:18) davin.baragiotta: (path au besoin, évidemment) (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) (16:12:54) davin.baragiotta: ce script n'est pas utile... (16:13:06) davin.baragiotta: mais vous pouvez expérimentez dans interpréteur (16:13:25) davin.baragiotta: pour trouver ce qui utile avec les objets existants (types de base) (16:13:26) davin.baragiotta: ou (16:13:38) davin.baragiotta: coder vos traitements... notamment vos fonctions (16:13:51) davin.baragiotta: je passe la partie FONCTIONS par manque de temps (16:14:08) davin.baragiotta: on pourra continuer dans un labo, si des gens sont intéressés (16:14:21) davin.baragiotta: finalement, je ne peut pas partir sans parler des IMPORT (16:14:43) davin.baragiotta: jusqu'ici, on a vu des notions "built-in"... qui viennent avec le langage : (16:14:50) davin.baragiotta: on lance interpéteur... c'est là (16:15:07) davin.baragiotta: mais y,a plein de fonctionnalités qui viennent aussi avec le langage, qu'il faut importer au besoin (16:15:23) davin.baragiotta: exemple : des types pour les dates, l'heure (16:15:29) davin.baragiotta: c'est dans datetime (16:15:48) davin.baragiotta: lisez la doc de la "standard library" Python (16:16:05) davin.baragiotta: les modules "qui viennent avec Python... mais qui faut importer pour les utiliser (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 : (16:16:41) davin.baragiotta: ex.: Django (16:16:49) davin.baragiotta: import django (16:16:54) davin.baragiotta: c'est un autre atelier... ;) (16:17:01) davin.baragiotta: des questions? (16:17:24) davin.baragiotta: CONCLUSION (16:17:30) davin.baragiotta: Python est simple et puissant (16:17:32) davin.baragiotta: vraiment (16:17:44) davin.baragiotta: pas juste pour l'AUF... pour tous les domaines (16:18:18) davin.baragiotta: l'apprendre vous donne la liberté de coder (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 (16:19:11) davin.baragiotta: ---------------------------------- FIN Atelier Python ----------------------------- }}}