line = self.precmd(line)
stop = self.onecmd(line)
stop = self.postcmd(stop, line)

cmd, arg, line = self.parseline(line)
if cmd == '':
    return self.default(line)
else:
    try:
        func = getattr(self, 'do_' + cmd)
    except AttributeError:
        return self.default(line)
    return func(arg)

#!/usr/bin/env python

import os
from time import sleep, strftime, localtime
import sys
import commands

filename = sys.argv[1]
mycommand = sys.argv[2]

def get_mtime():
    return os.stat(filename).st_mtime

mtime = get_mtime()
while 1:
    sleep(1)
    new_mtime = get_mtime()
    if mtime != new_mtime:
        mtime = new_mtime
        commands.getoutput(mycommand)
    print "done: %s ( %s )" % (mycommand, strftime("%a, %d %b %Y %H:%M:%S", localtime(mtime)))

$ wdo docutils.rst "make html"
done: make html ( Wed, 06 Apr 2011 05:12:30 )
done: make html ( Wed, 06 Apr 2011 05:26:27 )
done: make html ( Wed, 06 Apr 2011 05:28:36 )
done: make html ( Wed, 06 Apr 2011 05:33:35 )
done: make html ( Wed, 06 Apr 2011 05:33:45 )

>>> "test.tar.gz".rsplit('.')
['test', 'tar', 'gz']
>>> "test.tar.gz".rsplit('.',1)
['test.tar', 'gz']

$ split /\./, "test.tar.gz"
$VAR1 = 'test';
$VAR2 = 'tar';
$VAR3 = 'gz';
$ split /\./, "test.tar.gz", 2
$VAR1 = 'test';
$VAR2 = 'tar.gz';

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

# kzfm <kerolinq@gmail.com>

from mechanize import Browser
import smtplib
from email.MIMEText import MIMEText
from email.Header import Header
from email.Utils import formatdate
from pyquery import PyQuery as pq

email = 'XXXXXXXX@gmail.com'
password = 'XXXXXXXXXXXX'
amazon_url = 'https://affiliate.amazon.co.jp/'

def get_amazon_data():
    br = Browser()
    br.set_handle_robots(False)
    br.addheaders = [('User-agent', 'Mozilla/5.0 (X11; U; Linux i686; en-US; \
     rv:1.9.0.1) Gecko/2008071615 Fedora/3.0.1-1.fc9 Firefox/3.0.1')]

    br.open(amazon_url)

    br.select_form(name="sign_in")
    br["email"] = email
    br["password"] = password

    response = br.submit()

    d = pq(response.get_data())
    return [data.text for data in d('div').filter('.data')]

def send_mail(data):

    from_addr = email
    to_addr   = email
    subject   = u'Amazonアフィリエイト'
    body      = u"""
発送済み商品合計: %s
売上合計: %s
注文済み商品: %s
クリック数: %s
あなたのコンバージョン: %s
""" % tuple(data)

    msg = MIMEText(body.encode("utf-8"),'plain','utf-8')
    msg['Subject'] = Header(subject, 'utf-8')
    msg['From'] = from_addr
    msg['To'] = to_addr
    msg['Date'] = formatdate()

    s = smtplib.SMTP('smtp.gmail.com', 587)
    s.ehlo()
    s.starttls()
    s.ehlo()
    s.login(email, password)
    s.sendmail(from_addr, to_addr, msg.as_string())
    s.close()

if __name__ == '__main__':
    amazon_data = get_amazon_data();
    send_mail(amazon_data)

html:
        $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
        @echo
        @echo "Build finished. The HTML pages are in $(BUILDDIR)/html."

import cPickle

with open("list.txt","w") as f:
    cPickle.dump([1,2,3,4,5],f)

with open("list.txt","r") as f:
    a = cPickle.load(f)

print a

  Name                      File
  ----                      ----
m __main__                  pickletest.py
m cPickle                   /opt/local/Library/Frameworks/Python.framework/Versions/2.6/lib/python2.6/lib-dynload/cPickle.so

def match(pattern, string, flags=0):
    """Try to apply the pattern at the start of the string, returning
    a match object, or None if no match was found."""
    return _compile(pattern, flags).match(string)

def search(pattern, string, flags=0):
    """Scan through string looking for a match to the pattern, returning
    a match object, or None if no match was found."""
    return _compile(pattern, flags).search(string)

class Scanner:
    def __init__(self, lexicon, flags=0):
        from sre_constants import BRANCH, SUBPATTERN
        self.lexicon = lexicon
        # combine phrases into a compound pattern
        p = []
        s = sre_parse.Pattern()
        s.flags = flags
        for phrase, action in lexicon:
            p.append(sre_parse.SubPattern(s, [
                (SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
                ]))
        s.groups = len(p)+1
        p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
        self.scanner = sre_compile.compile(p)
    def scan(self, string):
        result = []
        append = result.append
        match = self.scanner.scanner(string).match
        i = 0
        while 1:
            m = match()
            if not m:
                break
            j = m.end()
            if i == j:
                break
            action = self.lexicon[m.lastindex-1][1]
            if hasattr(action, '__call__'):
                self.match = m
                action = action(self, m.group())
            if action is not None:
                append(action)
            i = j
        return result, string[i:]