Python : Atelier intermédiaire

INTRODUCTION

• Objectifs :
  • utiliser la bibliothèque standard et des packages existants
  • savoir coder ses propres objets

STANDARD LIBRARY et PACKAGES

Bibliothèque standard (standard library)

Modules explorés ou abordés pendant ateliers AUF :

• datetime
• pickle
• sqlite3
• re

Modules potentiellement utiles pour administrateurs système :

• subprocess

  import subprocess
  out = subprocess.call("grep -rsn 'davin' . > ~/Bureau/davin", shell=True)
  print out
  
  resultat = subprocess.Popen("grep -rsn 'davin' .", shell=True, stdout=subprocess.PIPE).communicate()[0]
  type(resultat)
  print resultat

  • shell=True pour commande juste en un string

• pwd

  # http://www.python.org/doc/lj21.html
  import posix
  import pwd
  pwd.getpwall()
  print 'hello', pwd.getpwuid(posix.getuid())[0]
  # progfou: et autre détail non négligeable pour nous à l'AuF : pwd fait des appels à la libc, qui passe par NSS, donc ça donne aussi les comptes réseau

• socket

  # socket.getaddrinfo pour faire de la résolution DNS
  import socket
  socket.getaddrinfo('smtp.sn.auf.org', 25)

• os.path
• sys

Autres modules d'intérêt :

• os.system
• zlib
• csv
• json
• email
• uuid
• urllib
• gettext
• pdb

Packages

pypi

• http://pypi.python.org/

  • numpy, scipy

    # fonctions d'optimisation
    
    def f(x) :
       return x**3 - x**2 -10
    
    from scipy import optimize
    optimize.fsolve(f, 1)

    Python African Tour (Dakar, 2009) : Informatique scientifique avec Python

  • android

    • Tutoriel en français (2009)

  • nltk
  • jabberbot
  • django

http://pypi.auf.org/

• auf.django.references

autres

• Fabric, Cuisine, Watchdog

• pyo

  from pyo import *
  s = Server().boot()
  s.start()
  wav = SquareTable()
  env = CosTable([(0,0), (100,1), (500,.3), (8191,0)])
  met = Metro(.125, 12).play()
  amp = TrigEnv(met, table=env, mul=.1)
  pit = TrigXnoiseMidi(met, dist='loopseg', x1=20, scale=1, mrange=(48,84))
  out = Osc(table=wav, freq=pit, mul=amp).out()
  s.stop()

CLASSES ET OBJETS

En Python, tout est un objet... on veut donc pouvoir créer nos propres objets en Python.

Classe et objets : structure et données

• Les classes sont une structure, un type de données
• Les objets sont les données, les variables de ce type
• Schéma :
  • Monde : objets réels (ou concepts)
  • Modélisation du domaine : conceptualisations, (pseudo) UML

  • Modélisation informatique : classes

  • Données : objets virtuels

Attributs et méthodes

• La classe est du code informatique qui

  • structure les données : attributs

    • un peu comme une table de DB a une structure : colonnes

  • déclare des traitements possibles sur ces données : méthodes (fonctions dans classe)

    • un peu comme une DB a traitement informatique possible sur données : procédures stockées

• méthodes : fonctions, donc callable

• attributs : variables

• nom des attributs et méthodes : visible dans introspection

Créer une Classe

class Personne():
    pass

• class

• convention de nommage : CamelCase

  • PersonneMorale : ok

  • personne_morale : pas ok

self

• représente l'objet en cours dans le code de la Classe

• nom générique : veut dire "quelque soit l'objet en cours, voici ce que je veux faire de cet objet"

• équivalent à this en Java ou PHP

Créer méthode d'initialisation d'objet

class Personne():
    def __init__(self, nom, prenom=""):
        self.nom = nom
        self.prenom = prenom

• self : toujours comme premier argument
• autres paramètres reçus lors d'initialisation (nom, prenom) sont stockés sur l'objet
• les attributs 'nom' et 'prenom' sur l'objet : self.nom, self.prenom, sont des variables avant une valeur propre à l'objet

Créer une (autre) méthode

class Personne():
    def __init__(self, nom, prenom=""):
        self.nom = nom
        self.prenom = prenom

    def nom_complet(self):
        return "%s %s" % (self.nom.upper(), self.prenom)

• Convention de nommage : lower_case

  • NomComplet : pas ok

  • nom_complet : ok
• self premier paramètre
• tout le reste : c'est simplement une fonction
  • (paramètres en input, traitement, return pour output)

CRUD d'objets

• Create : création d'objet

  davin = Personne(nom="Baragiotta", prenom="Davin")

  On utilise la classe pour créer un objet de cette classe.

  On passe en paramètre les infos nécessaires à __init__() pour créer l'objet.

  • vérification des attributs de l'objet davin

    davin. [+ tab] # ipython
    davin.nom
    davin.prenom

• Update : modification de l'objet

  davin.prenom = "Daniel"
  davin.prenom

• Delete : suppression de l'objet

  del davin

• Retrieve : récupération de l'objet n'a de sens si on a de la permanence de l'information.

  • Typiquement, on voudra stocker nos objets dans des bases de données en liant nos Classes à des tables. C'est ce que les ORM (Object-relational-mapper) font. Atelier Django montre comment récupérer les objets stockés dans DB.

Attributs et méthodes : de classe et d'objet

Héritage

• object

• si classe hérite : init DOIT appeler init de parent

  • appel de méthode de parent : ClassParent.methode(self) # self = obligatoire

AUTRES NOTIONS PYTHON

Décorateurs

Exceptions

EXERCICE

• créer une classe Personne
• créer une méthode fullname() sur la classe Personne retournant le nom complet d'un personne
• créer une classe Professeur qui hérite de Personne

CONCLUSION

• ne pas réinventer la roue : utiliser l'existant
• DIY (do-it-yourself) : pour le reste, faites du "sur mesure"
• yalla!