Atelier 2012-02-23 : Python : Atelier de base

INTRODUCTION

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

  • http://www.python.org/doc/

  • http://docs.python.org/tutorial/

  • http://docs.python.org/library/

• 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

NOTIONS DE BASE

Interpréteur

• python, ipython
• interactivité / introspection

$ ipython

Syntaxe

• 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/ (pour créer une 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 flux.py dans le répertoire projet/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!