Modifications entre les versions 11 et 15 (s'étendant sur 4 versions)
Version 11 à la date du 2012-02-22 22:45:10
Taille: 8768
Éditeur: DavinBaragiotta
Commentaire:
Version 15 à la date du 2012-02-22 23:03:19
Taille: 718
Éditeur: DavinBaragiotta
Commentaire:
Texte supprimé. Texte ajouté.
Ligne 1: Ligne 1:
= Atelier 2012-02-23 : Python : Atelier de base = = Python : Atelier de base =
Ligne 3: Ligne 3:
<<TableOfContents(3)>> == Infos générales ==
Ligne 5: Ligne 5:
----  * Date/heure : jeudi 23 février 10h00 Alexandrie (EG)
 * Durée : 5 heures
 * Lieu : CNF Alexandrie
 * Présentateur : DavinBaragiotta
 * Format : Atelier présentiel
Ligne 7: Ligne 11:
== INTRODUCTION == == Description ==
Ligne 13: Ligne 17:
 * Documentation
  * http://www.python.org/doc/
  * http://docs.python.org/tutorial/
  * http://docs.python.org/library/
== Pré-requis ==
Ligne 18: Ligne 19:
 * Environnement
  * éditeur texte
  * interpréteur python : python, ipython
  * sources :
   * http://montrealpython.org/r/projects/workshop-uqam-2011-11-17/wiki
   * http://montrealpython.org/r/attachments/2
=== Connaissances techniques ===
Ligne 25: Ligne 21:
----  * Bases en programmation (minimales)
Ligne 27: Ligne 23:
== NOTIONS DE BASE == === Environnement technique ===
Ligne 29: Ligne 25:
=== Interpréteur ===  * Python = 2.6
Ligne 31: Ligne 27:
 * python, ipython
 * interactivité / introspection
== Contenu de l'atelier ==
Ligne 34: Ligne 29:
{{{
$ ipython
}}}
 * [[/Plan|Plan et support de présentation de l'atelier]]
Ligne 38: Ligne 31:
=== Syntaxe === == Ressources ==
Ligne 40: Ligne 33:
 * commentaire : #
 * variables : sans $
 * instructions : sans ;
 * blocs : sans {}
 * style : PEP 8
 http://www.python.org/dev/peps/pep-0008/
 * bris de ligne : \

=== Variables ===

 * nom, valeur, référence
{{{
a = 12
b = a
id(a)
id(b)
}}}

=== Types ===

 * typage dynamique (pas besoin déclarer)
{{{
n = None # NoneType : type spécial voulant dire... rien
b = True # bool : booléen... True ou False n'oubliez pas les majuscules

i = 15 # int : entier
f = 15.5 # float : décimal

s = "chaine" # str : chaine de caractère, instancié avec "" ou ''
u = u"chaîne" # unicode : chaîne de caractère unicode, instancié avec u"" ou u''

l = [] # list : liste d'objets (ordonné)
t = () # tuple : liste immuable d'objets
d = {} # dict : dictionnaire de données (unique, non-ordonné)

ens = set([]) # set : ensemble (unique, non-ordonné)
}}}

 * unpacking
{{{
a, b = 34, 56
}}}

 * fortement typé (pas de transtypage implicite)
 * transtypage
 str(), int(), float(), bool(), list(), tuple(), dict(), set()
{{{
float(a)
}}}

=== Built-in : fonctions built-in et structure du langage ===

 * http://docs.python.org/library/fonctions.html
{{{
type() # retourne le type de l'objet
dir() # retourne les noms derrière l'objet
help() # retourne l'aide
callable() # dit si un objet est appelable, exécutable...

bool(), int(), str()... # initialisation ou transtypage
getattr()
isinstance(objet, Type) # teste le classe (ou type) d'un objet
issubclass()
super()
len()
min()
max()
open()
range()
raw_input()

print
del
}}}

=== Objets et namespaces ===

 * objet.attribut
 * objet.methode()
 * objet.attribut.methode()

=== Introspection ===

 * variable. [+ tab]
 * variable?

 * type()
 * dir()
 * help()

 * exploration des types

 * concaténation : s1 + s2

{{{
nom = "Davin Baragiotta"
prenom, nom = nom.split()
nom.upper()
nom.lower()
nom.ljust(30)
nom = [prenom.lower(), nom.lower()]
username = ".".join(nom)

nom = "Davin Baragiotta"
username = ".".join(nom.split()).lower()

users = []
users.append(username)

davin = {'prenom':'Davin', 'nom':'Baragiotta'}
pascal = {'prenom':'Pascal', 'nom':'Bou Nassar'}

personnes = []
personnes.append(davin)
personnes.append(pascal)

statuts = [
    (1, u'Nouveau'),
    (2, u'En cours'),
    (3, u'Rejeté'),
    (4, u'Retenu'),
]
}}}

=== Conteneurs ===

 * imbrication
{{{
l = [[1,2,3],[4,'salut',6],[7,8,9]]
d = {1611: {'nom':'Baragiotta', 'prenom':'Davin'}, 123: {'nom':'Bou Nassar', 'prenom':'Pascal'}}
}}}
 * index
{{{
l[2], d[1611]
}}}
 * slicing
{{{
l[0:2]
}}}

{{{
personne = {'nom':'x', 'prenom':'y'}
personnes = []
}}}

=== Itération ===

 * while
{{{
annee = 2012
while annee <= 2015:
    print annee
    annee = annee + 1 # annee += 1
}}}

 * for
{{{
for i in range(2012, 2016):
    print i
}}}

=== Comparaisons et opérateurs logiques ===

 * false = 0, "", (), [], {}, None
 * and, or, not
 * < > <= >= == !=
 * x < y <= z
 * is, is not
 * in, not in

=== Conditionnel ===

 * if, elif, else
{{{
liste = range(6)
if 5 in liste:
    print 'hourra 5'
elif 4 in liste:
    print 'hourra 4'
else:
    print 'pas hourra'
}}}

=== Fichiers ===

 * ouvrir, manipuler, fermer
{{{
f = open('texte.txt')
for line in f.readlines():
    print line,
f.close()
}}}

=== Formattage de chaînes de caractères ===

 * substitution : %
{{{
for n in range(10):
    print "La puissance 2 de %d est : %d" % (n, n**2)

for p in personnes:
    print "Bonjour %s %s" % (p['prenom'], p['nom'].upper())
}}}

=== Compréhension de liste ===

 * créer une liste à partir d'un itérable avec un "one-liner"
{{{
cible = 'egypte'
contexte = [ligne for ligne in f.readlines() if cible in ligne]
commentaires = [ligne for ligne in f.readlines() if l.startswith('#')]
}}}

----

=== Scripts ===

{{{
#! /usr/bin/env python
# -*- encoding: utf-8 -*-

def coucou(nom):
    return u"Coucou %s!" % (nom,)
        
if __name__ == '__main__':
    print u"--------------------------------------------------"
    print u"DÉBUT du script"
    print u"--------------------------------------------------"
    nom = raw_input("Quel est votre nom? ")
    print coucou(nom)
    print u"-----------------------------------------------"
    print u"FIN du script"
    print u"-------------------------------------------------"
}}}
 * shebang : #! /usr/bin/env python
 * encoding : # -*- encoding: utf-8 -*-
{{{
if __name__ == '__main__':
}}}
 * raw_input()

 * créer un répertoire '''projet/annuaire'''
 * créer dans ce répertoire un script Python nommé '''form.py''' qui demande à l'utilisateur son nom, prénom et année de naissance

=== Fonctions ===

 * convention de nommage
 * output : None par défaut
 * input : paramètres positionnels, nommés, *args, **kwargs
 * portée des variables

{{{
def age(annee_naissance):
    return 2012 - annee_naissance

def ma_fonction(param1, param2, param3=None, param4=0, *args, **kwargs):
    """Ceci est ma fonction."""
    output = True
    return output
}}}

=== Import ===

 * import module
 * from module import nom
 * from module import nom as mon_nom

 * built-in : pas besoin d'import
 * standard library (shipped in) : import sans install
 * packages : importable si installé dans le path

{{{
import sys
sys.path
}}}

 * dans le répertoire '''projet/annuaire''', créer un script Python nommé '''lib.py'''
 * déclarer la fonction '''age''' dans ce script
 * dans ipython, s'assurer d'être dans '''projet/annuaire''' puis tester l'import de la fonction
{{{
import lib
mon_annee_naissance = 1975
lib.age(mon_annee_naissance)
}}}
 * améliorer '''form.py''' en saluant le user qui a rempli le form et en lui donnant son âge

=== Modules ===

 * {{{__init__.py}}}
 * {{{__name__}}} : nom du module, nom de fichier si importé, {{{'__ main __'}}} si exécuté (utile pour tests)
 * ajouter un fichier {{{__init__.py}}} dans le répertoire '''projet/annuaire''' pour le convertir en module
 * créer un fichier '''tests.py''' à la racine du répertoire '''projet/''' (suite de tests)
 * importer la fonction age dans '''tests.py''' pour la tester

=== Permanence de l'information ===

 * fichiers
 * sérialisation : import pickle
{{{
import pickle

f = open('pickles', 'w')
pickle.dump(statuts, f)
pickle.dump(personnes, f)
f.close()

exit()

import pickle

f = open('pickles')
objets = []
for obj in pickle.load(f):
    objets.append(obj)
f.close()
}}}
 * DB : sqlite3, mysqldb, psycopg2
 * ORM : sqlalchemy

== EXERCICE ==

=== Objectif ===

Créer un script 'actualites' qui retournera les
5 dernières actualités affichées sur le site institutionnel de l'AUF :
http://www.auf.org/flux/actualite/

=== Approche ===

1. utiliser python-feedparser
 * sudo apt-get install python-feedparser

2. lancer interpréteur et suivre exemple de la doc :
 * ipython
 * http://feedparser.org/

3. introspecter (et imprimer dictionnaire pour voir ses clés) au besoin

4. coder un script qui fera le traitement voulu
 * à partir du modèle code/script.py

5. lancer le script dans l'interpréteur pour confirmer son exécution correcte

6. servir froid

=== Algorithme ===

 * capter le flux RSS de www.auf.org
 * retenir le nombre d'items voulus
 * traiter les items retenus :
  * créer une chaîne de caractères unique
    avec les infos des derniers items modifiés

=== Solution ===

Des solutionnaires à cet exercice vous sont présentés
dans :
exercice-solutions.txt

Pour info, la solution ne fait que 8 lignes Python.

== CONCLUSION ==

 * documentation + interactivité + introspection
 * scripts + modules
 * enjoy!
 * Sources : [[attachment:exercice-solution.txt]]

Python : Atelier de base

Infos générales

  • Date/heure : jeudi 23 février 10h00 Alexandrie (EG)
  • Durée : 5 heures
  • Lieu : CNF Alexandrie
  • Présentateur : DavinBaragiotta

  • Format : Atelier présentiel

Description

  • Objectifs :
    • coder dans l'interpréteur et explorer les bases du langage
    • écrire un script qu'on fera exécuter par l'interpréteur

Pré-requis

Connaissances techniques

  • Bases en programmation (minimales)

Environnement technique

  • Python = 2.6

Contenu de l'atelier

Ressources

Ateliers/2012-02-23 (dernière édition le 2012-08-27 07:04:58 par DavinBaragiotta)