J'ai trouvé ce code assurément intéressant sur pythonfrance.com, et son auteur s'appelle kerneltony95. Compte tenu de la nature de ce programme, je tiens à rappeller que le but de cet article est d'apprendre comment les spammeurs récupèrent votre adresse e-mail, certainement pas de vous livrer à ce genre de gamineries vous même.
Pour ceux à qui l'idée traverserait l'esprit, sachez que Christopher William Smith, surnommé à juste titre le roi du spam, à récemment été condamné à 30 ans de taule! ça calme, hein?

Bon, assez discuté, voyons ce qui nous interesse, à savoir le code en lui-même:

#!/usr/bin/python

import sys
import re
import string
import httplib
import urllib2
import re

def StripTags(text):
    finished = 0
    while not finished:
        finished = 1
        start = text.find("<")
        if start >= 0:
            stop = text[start:].find(">")
            if stop >= 0:
                text = text[:start] + text[start+stop+1:]
                finished = 0
    return text

if len(sys.argv) != 2:
        print "\nrsx.py : Trouvez les e-mail sur google extention de goog-mail beta by tOny.\n"
        print "\nUsage : ./rsx.py \n"
        print "\nexemple: ./rsx.py hotmail.com \n"
        sys.exit(1)

domain_name=sys.argv[1]
d={}
page_counter = 0
try:
    while page_counter <400:
        results = 'http://groups.google.com/groups?q='+str(domain_name)+'&hl=en&lr=&ie=UTF-8&start=' + repr(page_counter) + '&sa=N'
        request = urllib2.Request(results)
        request.add_header('User-Agent','Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 5.0)')
        opener = urllib2.build_opener()
        text = opener.open(request).read()
        emails = (re.findall('([\w\.\-]+@'+domain_name+')',StripTags(text)))
        for email in emails:
            d[email]=1
            uniq_emails=d.keys()
        page_counter = page_counter +10
except IOError:
    print "erreur les e-mails de la companie sont introuvable sur Google Groupes !"+""
page_counter_web=0
try:
    print "\n\n+++++++++++++++++++++++++++++++++++++++++++++++++++++"+""
    print "+ rsx resultat de Google Groupes & web:"+""
    print "+++++++++++++++++++++++++++++++++++++++++++++++++++++\n\n"+""

    while page_counter_web >400 :
        results_web = 'http://www.google.com/search?q=%40'+str(domain_name)+'&hl=en&lr=&ie=UTF-8&start=' + repr(page_counter_web) + '&sa=N'
        request_web = urllib2.Request(results_web)
        request_web.add_header('User-Agent','Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 5.0)')
        opener_web = urllib2.build_opener()
        text = opener_web.open(request_web).read()
        emails_web = (re.findall('([\w\.\-]+@'+domain_name+')',StripTags(text)))
        for email_web in emails_web:
            d[email_web]=1
            uniq_emails_web=d.keys()
        page_counter_web = page_counter_web +10

except IOError:
    print "erreur les e-mails de la companie sont introuvable sur google web !"+""
for uniq_emails_web in d.keys():
    print uniq_emails_web+""

Ce programme fonctionne en ligne de commande. Utilisez la syntaxe suivante:

python rsx.py hotmail.fr

Assez impressionnant de voir que l'on peut trouver des centaines d'adresses e-mail avec simplement 67 lignes de code. On ne le répetera jamais assez, ne mettez jamais votre mail sur le web!

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

#  notebook.py

import pygtk
pygtk.require('2.0')
import gtk

class NotebookExample:
    def add_icon_to_button(self,button):
	"Fonction pour ajouter un bouton fermer"
	#création d'une boite horizontale
        iconBox = gtk.HBox(False, 0)
	#Création d'une image vide
        image = gtk.Image()
	#On récupère l'icone du bouton "fermer"
        image.set_from_stock(gtk.STOCK_CLOSE,gtk.ICON_SIZE_MENU)
	#On enlève le relief au bouton (donné en attribut)
        gtk.Button.set_relief(button,gtk.RELIEF_NONE)
	#On récupère les propriétés du bouton
        settings = gtk.Widget.get_settings(button)
	#On affecte à w et h les dimensions
        (w,h) = gtk.icon_size_lookup_for_settings(settings,gtk.ICON_SIZE_MENU)
	#On modifie ces dimensions
        gtk.Widget.set_size_request(button, w + 4, h + 4)
        image.show()
	#On met l'image dans la boite
        iconBox.pack_start(image, True, False, 0)
	#On ajoute la boite dans le bouton
        button.add(iconBox)
        iconBox.show()
        return 

    def create_custom_tab(self,text, notebook, frame):
        "Crée une tab customisée avec un label et un bouton fermer"
	#On crée une eventbox
        eventBox = gtk.EventBox()
	#On crée une boite horizontale
        tabBox = gtk.HBox(False, 2)
	#On crée un label "text" (text donné en attribut)
        tabLabel = gtk.Label(text)
	#On crée un bouton
        tabButton=gtk.Button()
	#On lui affecte la méthode remove_book
        tabButton.connect('clicked',self.remove_book, notebook, frame)

        #On ajoute l'image au bouton en utilisant la méthode add_icon_to_button
        self.add_icon_to_button(tabButton)

        eventBox.show()
        tabButton.show()
        tabLabel.show()
	#On attache label et bouton à la boite
        tabBox.pack_start(tabLabel, False)
        tabBox.pack_start(tabButton, False)

        tabBox.show_all()
	#On ajoute la boite à l'eventbox
        eventBox.add(tabBox)
        return eventBox

    def remove_book(self, button, notebook, frame):
	"Fonction de suppression de page"
	#On supprime la page. Le secret, c'est de donner comme argument le widget enfant de la page, ici un cadre frame.
        notebook.remove(frame)
        # On actualise le widget
        notebook.queue_draw_area(0,0,-1,-1)

    def delete(self, widget, event=None):
        gtk.main_quit()
        return False

    def __init__(self):
        window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        window.connect("delete_event", self.delete)
        window.set_border_width(10)

        #On crée un nouveau notebook
        notebook = gtk.Notebook()
        window.add(notebook)
        notebook.show()

        # On ajoute quelques pages
        for i in range(5):
            page_number = i + 1
            frame = gtk.Frame("Frame %d" % page_number)
            frame.set_border_width(10)
            frame.set_size_request(100, 75)
            frame.show()
            label = gtk.Label("Dans la Frame %d" % page_number)
            frame.add(label)
            label.show()

            eventBox = self.create_custom_tab("Tab %d" % page_number, notebook, frame)
            notebook.append_page(frame, eventBox)
        # Page que nous verrons à l'ouverture (page 4)
        notebook.set_current_page(3)
        window.show()

def main():
    gtk.main()
    return 0

if __name__ == "__main__":

    NotebookExample()

    main()

Et voilà le résultat du code ci-dessus. Beau boulot

Avant de commencer

Le site du module: http://pymedia.org/
La documentation: Documentation

Installation sous GNU/Linux:
Pour les utilisateurs Debian/Ubuntu, un paquet .deb est disponible ici: paquet pymedia pour Debian/Ubuntu
Installez-le via votre gestionnaire de paquets.

Installation sous Windows:
Les utilisateurs de windows trouveront un fichier .exe ici
Ouvrez-le et il s'installera automatiquement.

Les exemples:

Un player audio minimal:

import pymedia
import time

player = pymedia.Player() #Création de l'objet player
player.start()
player.startPlayback('unFichierSon.mp3') #Chemin du fichier son à  lire

while player.isPlaying(): #On boucle tant que la lecture n'est pas terminée
    time.sleep( 0.01 )

Le module pymedia.player permet de lire facilement les types de fichiers musicaux supportés par pymedia.

Un meilleur exemple avec un Thread:

import threading
import time
import pymedia
from Tkinter import *

class playFile(threading.Thread):

	def __init__(self, file_name):
		global player
		threading.Thread.__init__ (self)
		player= pymedia.Player()
  		player.start()
		self.keepGoing = True
  		player.startPlayback(file_name)

	def run(self):
		global player
		while player.isPlaying() and self.keepGoing:
    			time.sleep( 0.01 )

	def stop(self):
		global player
		player.stopPlayback()
		self.keepGoing = False

def play():
    global pf
    pf = playFile("a.mp3") #le fichier son à  jouer
    pf.start()

def stop():
    global pf
    pf.stop()

#La GUI
root= Tk()
play = Button(text="play", command=play)
play.pack()
stop = Button(text="stop", command=stop)
stop.pack()
e = Entry()
e.pack()
root.mainloop()

Cet exemple utilisant les Threads, il est necessaire de s'assurer que tous les threads ont été stoppés avant de quitter l'application, sinon gare aux mauvaises surprises. L'utilisation du thread permet -outre le fait de disposer d'une classe totalement réutilisable- l'execution simultanée de deux portions de code distinctes, à savoir l'interface graphique Tk et les fonctions de controle du son.

La documentation du module pymedia.player liste les différentes méthodes disponibles.

Téléchargez l'archive sur http://www.pyinstaller.org/ et décompressez là sur votre machine.
Sous Linux, assurez vous d'avoir installé les paquets python-dev et zlib1g-dev.
Executez Configure.py et déplacez-vous dans source/linux. Ensuite, executez Make.py puis la commande make.Si tout s'est bien déroulé, les bootloaders (run et run_d) auront été créés dans support/loader.

Sous windows, vous n'avez qu'à télécharger et décompresser l'archive.
Pour la suite du tuto, je considèrerais pyinstaller installé dans le répertoire /home/pyinstaller.

Choisissez un script Python qui sera votre premier script compilé avec Pyinstaller. Pour plus de confort, déplacez le dans le dossier racine de pyinstaller. Pour cet exemple, notre script à compiler s'appellera script.py

Ouvrez une console. Déplacez vous jusqu'au répertoire de pyinstaller. dans le cadre de notre exemple, cela donne: /home/pyinstaller/pyinstaller-1.3 puis Executez le script de configuration en tapant Configure.py .Vous devriez voir apparaitre ce genre de messages à l'écran:

C:pyinpyinstaller-1.3>Configure.pyI: computing EXE_dependenciesW: Cannot determine your Windows or System directoriesW: Please add them to your PATH if .dlls are not found
W: or install starship.python.net/skippy/win32/Downloads.html
I: Finding TCL/TK...
I: found TCL/TK version 8.4
I: testing for Zlib...
I: ... Zlib available
I: Testing for ability to set icons, version resources...
I: ... resource update unavailable - No module named win32api
I: Testing for Unicode support...
I: ... Unicode available
I: testing for UPX...
I: ...UPX unavailable
I: computing PYZ dependencies...

Nous allons maintenant créer le fichier spec grace au script Makespec.py.

Makespec.py accepte de nombreuses options pour la création de votre fichier exe. Les voici:

-h, --help	Affiche l'aide
-F, --onefile	Créer un seul fichier executable
-D, --onedir	Créer l'executable sous forme d'un répertoire de plusieurs fichiers (défaut)
-w, --windowed, --noconsole	Ne pas afficher la console lors de l'execution (Windows uniquement)
-c, --nowindowed, --console	Afficher la console à l'execution (Windows uniquement)
-a, --ascii	N'inclus PAS l'encodage unicode (Par défaut, inclus si disponible)
-d, --debug	Mode verbeux.
-s, --strip	Supprime le fichier exe et les libs partagées. Ne pas essayer sous Windows
-X, --upx	Utilise UPX si disponible.
-K, --tk	Inclus TCL/TK.
-o DIR, --out=DIR	Génère le fichier spec dans le répertoire spécifié.
-n NAME, --name=NAME	Nom du projet. Par défaut, le nom utilisé sera celui du script.
-p DIR, --paths=DIR	Définit le répertoire pour les imports (Il est possible de spécifier plusieurs répertoires en les séparant d'un point virgule ";".
-v FILE, --version=FILE	Ajoute un fichier de ressource version à l'éxecutable.
--icon=FILE.ICO or FILE.EXE,ID	Ajoute l'icone (.ico uniquement) spécifiée au projet. Vous devez avoir installé pywin32 pour utiliser cette option.

Pour compiler script.py en un seul fichier executable:
Makespec.py -F "script.py"
La console renverra le message suivant, vous indiquant ou se trouve votre fichier spec:
wrote pyinpyinstaller-1.3scriptscript.specnow run Build.py to build the executable
Il ne reste plus qu'a executer la commande Build.py pour construire l'executable:
Build.py "script/script.spec"
Si tout s'est bien passé, vous trouverez un répertoire pourtant le nom de votre script (donc, dans le cadre de ce exemple, le répertoire s'appelle script), votre fichier executable est dedans.

Vous pouvez désormais distribuer l'executable, il sera fonctionnel même si l'utilisateur final n'a pas installé Python ou un de ses modules externes.

Si vous avez eu des erreurs lors de compilation, ou si votre executable ne fonctionne pas, vous pouvez consulter le fichier warn.txt qui donne des informations sur les problemes qu'a pu rencontrer pyinstaller lors de la compilation.

On y va Tout d'abord, il faut créer un fichier appellé control-install, avec ce contenu:

Package: test
Version: 0.1
Section: utils
Priority: optional
Architecture: i386
Depends: python (>=2.4), python-xml (>=0.8)
Maintainer: vous (vous@gmail.com)
Description: Juste un test de paquet Debian

Modifiez les valeurs à votre convenance, en prenant grand soin de renseigner avec exactitude les dépendances liées à votre programme. Dans le cas contraire, et si l'utilisateur de votre programme n'a pas ces dépendances d'installées sur sa machine, votre programme ne fonctionnera pas.

Créez le script suivant sur votre machine et nommez le create_package.sh:

#!/bin/sh
INSTALL_DIR="/usr/share/test"
MAN_DIR="/usr/share/man/test"
BIN_DIR="/usr/bin"
APP_DIR="/usr/share/applications"
LOC_DIR="/usr/share/locale"
ICO_DIR="/usr/local/share/pixmaps"
VERSION=`cat control-install | grep "Version" | cut -d  -f2`

mkdir -p test/DEBIAN
cp control-install test/DEBIAN/control

mkdir -p "test"$ICO_DIR
cp pix/test.png "test"$ICO_DIR

mkdir -p "test"$MAN_DIR
cp doc/test "test"$MAN_DIR

mkdir -p "test"$INSTALL_DIR
mkdir -p "test"$INSTALL_DIR"/src"
cp src/*.py "test"$INSTALL_DIR"/src/"

mkdir -p "test"$INSTALL_DIR"/res"
cp res/*.glade "test"$INSTALL_DIR"/res/"

mkdir -p "test"$INSTALL_DIR"/pix"
cp pix/*.png "test"$INSTALL_DIR"/pix/"

mkdir -p "test"$INSTALL_DIR"/doc"
cp doc/gpl.txt "test"$INSTALL_DIR"/doc/"

cp doc/whatsnew.txt "test"$INSTALL_DIR"/doc/"
mkdir -p "test"$APP_DIR

cp res/*.desktop "test"$APP_DIR
mkdir -p "test"$BIN_DIR

cp start-install.sh "test"$BIN_DIR"/test"
mkdir -p "test"$LOC_DIR

cp -R locale/* "test"$LOC_DIR

dpkg-deb --build test test-$VERSION.deb
rm -rf test

Placez le au même niveau que la source de votre programme et du fichier control-install puis rendez-le executable :

sudo chmod +x create_package.sh

Ensuite, vous devez modifier "test" par le nom de votre programme. Pour remplacer toutes les occurences de test par monprogramme, ouvrez create_package.sh sous VI et procédez comme suit:
:%s/test/monprogramme/g

Avant d'éxecuter le script, pensez à relire le script et à remplacer certaines valeurs qui ne correspondraient pas à l'arborescence de votre programme. Par exemple, le script considère par défaut que vos images sont dans un dossier pix.

Une fois que tout est prêt, un bon
sudo ./create_package.sh
et votre paquet Debian trône fièrement devant vous