Atelier du vendredi 18 avril 2014 par FX


Après un bref rappel des notions abordées aux précédents ateliers de nouveaux éléments fondamentaux du langage ont été présentés:
  • le formatage de chaîne analogue au classique printf :
  • la définition d'une fonction
    • def add(a,b,c):
      • return a+b+c
    • add(1,10,100) # le résultat est 111
    • def meteo(temperature, ciel, date="demain"): # definition de paramètre(s) par défaut
      • print date+", le ciel sera"+ciel+" et il fera "+str(temperature)+" °".
    • meteo(25,"bleu")
    • meteo(22,"nuageux","mardi")
    • meteo(28, date="dimanche",ciel="clair") # nommage des paramètres
  • la fonction str ainsi que la fonction int
    • l'une transforme un nombre en une chaine
    • l'autre transforme une chaine en nombre
    • print int("1")+int("10")+int("100") # le résultat est 111
  • la fonction dir() ainsi que la fonction type()
    • par exemple : dir(object) ou type(2014)
  • la définition d'une classe avec ses méthodes (notamment la méthode init ) et ses attributs ainsi que la création de plusieurs
instances de cette classe. Par convention, self désigne toujours le premier argument d'une méthode de classe (la référence à l'instance en cours). object est la super classe dont hérite toutes les autres classes.
#!/usr/bin/env  python
# -*- coding: utf-8 -*-
# pythonpoo.py
# vendredi 18 avril 2014
# première classe, premières instances (merci FX)
###########################################################
class voiture(object):
 # notre première classe
 color="rouge"
 def couleur(self,color):
       return self.couleur
 def demarrer(self):
       print("vroum-vroum")
       return

ferrari=voiture() # création d"une instance
ferrari.couleur ="rouge"
ferrari.demarrer  #appel par l'instance
voiture.demarrer(ferrari) # appel par la classe
renault = voiture()



Exercise proposé :
On suppose qu'on a la liste suivante :
daltons=[{"nom":"joe","taille":140,"caractere":"teigneux"},
         {"nom":"jack","taille":155,"caractere":"idiot"},
         {"nom":"william","taille":170,"caractere":"stupide"},
         {"nom":"averell","taille":185,"caractere":"abruti"}]

Ecrire une fonction compare_taille qui prenant en argument deux daltons (deux tables de hachage, en fait), comparant leur attribut "taille", et renvoyant :
    zéro s'ils sont de même taille
    un nombre négatif si le premier est plus petit
    un nombre positif si le premier est plus grand

Ecrire aussi une fonction compare_nom prenant en argument deux daltons, comparant leur attribut "nom", et renvoyant :
    zéro s'ils sont identiques
    un nombre négatif si le premier est avant le second dans l'ordre alphabétique
    un nombre positif si le premier est après le second dans l'ordre alphabétique

Exécuter le code suivant pour tester les fonctions :
print daltons
daltons.sort(compare_nom)
print daltons
daltons.sort(compare_taille)
print daltons

# notion de listes en compréhension
liste_en_comprehension = [dalton['nom'] for dalton in daltons]
print liste_en_comprehension
def compare_taille(a, b):   return ??????????????????


Un des participants à l'atelier, à précisé d'une part la notion de Duck typing :
et d'autre part le fait qu'en Python les fonctions anonymes (les fameuses lambda) sont plus limitées que les véritables fermetures lexicales ( en anglais : closures) d'autres langages :

Référence de l'ensemble des ateliers Python http://wiki.linux-azur.org/AtelierPYTHON