J'ai ajouté une section Livres sur le site, pour y détailler quelques livres. C'est le site bookshelved de Laurent Bossavit qui m'en a donné l'idée.

La section devrait se remplir plus tard, quand j'aurais plus de temps pour y présenter d'autres livres.

Je me suis donné une heure pour écrire le script qui extraira de la boîte 'concourspython@gmail.com' les 5 gagnants au jeu jeudi prochain.

L'objectif n'était pas ici de faire un script bien léché, réutilisable ou organisé en classes, mais plutôt d'obtenir le résultat rapidement.

Grâce à libgmail et bien sur les modules standards comme email ou random, j'ai pu mettre au point ce script en moins de 70 lignes

Quel bonheur Python

import libgmail
import sys
import random
from email import message_from_string

# réponses bidons bien sûr ;)
results = ['1:a', '2:a', '3:a', '4:a', '5:a', '6:a', '7:a']

def qualifyContent(message_source):
    """ test if the mail wins """
    qualification = [False] * 7
    for line in message_source.strip().split():
        line = line.strip()
        if line in results:
            qualification[results.index(line)] = True
    return False not in qualification

def extractContent(message_source):
    """ get the mail body """
    message = message_from_string(message_source)
    payload = message.get_payload()
    if isinstance(payload, list) and len(payload) > 0:
        # trying first part
        payload = payload[0].get_payload()
    if not isinstance(payload, str):
        return None
    return payload

def getResults(login, password):
    """ retrieve mails from gmail and qualify them
    winners / losers / failures
    """
    ga = libgmail.GmailAccount(login, password)
    ga.login()
    failures = []
    losers = []
    winners = []
    folder = ga.getMessagesByFolder('inbox', allPages=True)
    current = 0
    for thread in folder:
        for msg in thread:
            if not current % 5:
                sys.stdout.write('%d' % current)
            else:
                sys.stdout.write('.')
            sys.stdout.flush()
            message = extractContent(msg.source)
            if message is None:
                failures.append(msg.source)
            elif qualifyContent(message):
                winners.append(msg.sender)
            else:
                losers.append(msg.sender)
            current += 1
    sys.stdout.write('\n')
    return winners, losers, failures, current

winners, losers, failures, num_players = getResults("concourspython@gmail.com",  "secret")
print '%d mails received' % num_players
print '%d winners' % len(winners)
print str(winners)
print '%d losers' % len(losers)
print str(losers)
print '%d failures' % len(failures)
print str(failures)
print 'picking up winners'
random.shuffle(winners)
final_winners = random.sample(winners, 5)
print str(final_winners)

Je remet à jour cette entrée, car beaucoup de gens ont souhaité un comparatif réel.
(il reste très sommaire, sans exemples de codes).

Le langage Ruby est très proche de Python. Il est dynamique, doté d'un prompt interactif, et où tout élément est objet. La syntaxe de Ruby est également clair et concise.

Les différences majeures à l'heure actuelle, sont:

• Ruby permet l'exécution de code dans un environnement restreint, fonctionnalité retirée de python il y a quelques temps, et encore sans équivalent.
• Python gère nativement Unicode, contrairement a Ruby qui pour l'instant ne gère l'unicode que dans ses expressions régulières. Ruby 2 gerera l'unicode.
• Seul Python permet l'utilisation de threads préemptifs.
• Python offre l'héritage multiple, Ruby propose quant à lui un système de mixin
• Les bibliothèques disponibles sous Python sont plus complètes et plus matures à l'heure actuelle, meme si Ruby comble le fossé (scipy -> sciruby, py2exe -> rubyscript2exe, etc)
  
• Python propose des systèmes d'interfaces (zope.interfaces, PyProtocoles, etc)

• La syntaxe de Ruby n'oblige pas le développeur à expliciter les instances d'objets comme premier paramètre masqué de la méthode. Cette approche est plus naturelle.
• L'indentation étant l'élément structurant du langage Python, il dispose d'une convention d'écriture explicite.
  

Merci à la communauté RubyFr (irc: #rubyfr) qui m'a aidé à compléter ce petit comparatif.

• un comparatif en anglais avec Perl, et des exemples de code
  
• un comparatif par rubyfr
  
• Un comparatif très complet en anglais, mais datant de 2001

En terme de nombre de développeurs:

• Index TIOBE
• Google Fight ;)

Ca y est, mon livre sort

ip ip ip, hura !

Au prochain..

Source
Une foule qui s'est amassée Bvd Saint Germain pour acheter un exemplaire dès l'ouverture demain matin. La circulation a été bloquée dans tout le quartier.

J'ai le map bien trop bas, j'ai l'filter qui s'dilate...

Ca fait maintenant plusieurs années que Guido parle de supprimer map(), filter(), reduce(), etc.. du langage, ce qui arrivera un jour puisque 50% de la communauté est en faveur de ce retrait, 25% contre et 25% sans opinions. lambda suivra probablement même chemin.

Mais que reste-t-il aux développeurs qui usent et abusent de ces primitives pour faire de la programmation fonctionnelle ?

... roulement de tambours ...

itertools ! qui offre des utilitaires de création d'itérateurs.

Iterators ? Generators ? Yield ?

itertools regroupe des fonctions de génération d'itérateurs, ces objets renvoyés par des generators, basés sur la directive yield, qui permet de sauvegarder des états d'exécution de la fonction.

-> Plus d'infos sur yield dans le manuel de référence

Un exemple typique de l'utilisation des generators, est l'implémentation de la suite de Fibonnaci:

def fibonnaci():
    x = 0
    y = 1 
    while 1: 
        x, y = y, x + y 
        yield x

Cette fonction renvoie un itérateur sans fin, qui permet de parcourir la suite:

>>> def fibonnaci():
...     x = 0
...     y = 1 
...     while 1: 
...         x, y = y, x + y 
...         yield x 
... 
>>> my_fib = fibonnaci() 
>>> my_fib.next() 
1 
>>> my_fib.next() 
1 
>>> my_fib.next() 
2 
>>> my_fib.next() 
3 

Ce principe peut être utilisé pour implémenter tout type de besoin, et à fortiori remplacer map(), filter(), reduce() et zip().

Contenu d'itertools

• chain(*iterables): renvoie un iterator composé de tous les éléments fournis dans les iterables.                                                                
• count([firstval]): Permet de retourner un iterator qui renvoie des entiers incrémentés par pas de 1. Si firstval est fourni, il est le premier entier renvoyé. Sinon count() utilise 0.                                                        
• cycle(iterable): Renvoie un iterator qui permet de parcourir indéfiniment les éléments de l'itérable.                                                          
• groupby(iterable[, keyfunc]): Renvoie un iterator qui permet de récupérer des couples (clé, groupe). keyfunc est une fonction qui doit renvoyer la clé pour l'élément courant. groupe est un itérable qui réunit les éléments regroupés par clé.
• ifilter(predicate, iterable): Permet de renvoyer un iterator qui contient les éléments de l'itérable fourni, lorsque le callable predicate renvoie vrai. Si predicate vaut None, les valeurs sont testées avec bool().
• imap(function, *iterables): Renvoie un iterator qui appelle function avec les éléments des itérables fournis, concaténés pour former la liste des paramètres. Si function vaut None, renvoie les paramètres préparés.
• islice(iterable, [start,] stop [, step]): Permet de renvoyer un itérable qui est une sous-séquence de l'itérable fourni. start, stop et step s'utilisent comme les tranches.
• izip(*iterables): Fonctionne comme zip(), pour agréger les éléments des itérables fournis.
• repeat(element, times): Génère un iterator qui répète element times fois. Si times n'est pas fourni, devient un iterator infini qui renvoie toujours element.
• starmap(function, sequence): Comparable à imap() mais le deuxième argument doit être une séquence de tuples. À chaque itération n, l'iterator renvoie le résultat de function(*sequence[n]).
• takewhile(predicate, iterable): Renvoie les éléments de iterable tant que predicate(element) renvoie True.
• tee(iterable[, n=2]): Découpe iterable en n itérables, renvoyés sous la forme d'un tuple. Chaque itérable renvoie ensuite les éléments de iterable.

Toutes ces fonctions peuvent être combinées, pour obtenir des mécanismes très puissants.

A chaque fois que vous vous apprêter à ajouter un appel à map(), zip() et consort, allez plutôt faire un tour du coté d'itertools...

On parle beaucoup de Jython, IronPython, etc.. Mais qui utilise ces implémentations ? Quelle est la proportion des développeurs Jython/CPython/etc.. ? J'ai mis en ligne un sondage ici: Sondage AFPY

Il ne répondra pas évidemment à cette question mais permettra peut être de se rendre compte (vaguement) des proportions.

J'ai été contacté il y a peu pour être responsable d'une session dans une conférence à Orlando aux U.S. Un peu étonnant, vu que je suis quasiment inconnu :)

On m'a signalé par la suite que ces conférences étaient une vaste arnaque, élaborée pour récupérer des droits d'inscriptions des conférenciers

Certains ont même conçu un générateur automatique de papiers à envoyer à ces conférences pour vérifier leur sérieux. Ils ont même été retenus sur certaines confs :). Outil à essayer absolument si vous ne connaissez pas!

• Générateur de papiers
• Quelques photos des créateurs de SCIGen qui sont allés présenter leurs faux papiers à Orlando

xp-france organise une conférence sur les techniques agiles en Mars à Paris. Python sera bien évidemment de la partie !

>> Communiqué complet ici <<