urllib 模块是标准 Python 库的一部分。它包含了一些函数，可以从基于互联网的 URL (主要指网页) 来获取信息并且真正取回数据。urllib 模块最简单的使用是提取用 urlopen 函数取回的网页的整个文本。打开一个 URL 同 打开一个文件相似。urlopen 的返回值是象文件一样的对象，它具有一个文件对象一样的方法。使用由 urlopen 所返回的类文件对象所能做的最简单的事情就是 read，它可以将网页的整个 HTML 读到一个字符串中。这个对象也支持 readlines 方法，这个方法可以将文本按行放入一个列表中。当用完这个对象，要确保将它 close，就如同一个普通的文件对象。

from sgmllib import SGMLParser

class URLLister(SGMLParser):
    def reset(self):
        SGMLParser.reset(self)
        self.urls=[]
        self.imgs=[]
    def start_a(self, attrs):
        href = [v for k, v in attrs if k=='href']
        if href:
            self.urls.extend(href)
    def start_img(self, attrs):
        img = [v for k, v in attrs if k=='src']
        if img:
            self.imgs.extend(img)

Install Apache 2.x : http://httpd.apache.org/
Install mod_python : http://www.modpython.org/

安装PIL:http://www.pythonware.com/products/pil/

PIL是Python Imaging Library缩写，主要用来处理图片用的，这里安装它是为了在Django系统中用它来对上传的图片自动的生成缩略图的。安装方法也相当的简单，直接双击运行PIL-1.1.5.win32-py2.4.exe这个文件，然后一路next即可。因为之前已经安装好了python，所以PIL的安装程序会从注册表中读取到python安装的路经，然后就自动地把PIL安装到python\lib\site-packages\PIL下面了

创建项目：django-admin.py startproject myproject
   cd myproject
   python manage.py runserver

创建app：manage.py startapp wiki

初始化数据库，使用 django-admin.py 或 manage.py 都可以: manage.py syncdb

    最简单的同步机制就是“锁”

    锁对象用threading.RLock类创建

    mylock = threading.RLock()

    如何使用锁来同步线程呢？线程可以使用锁的acquire() （获得）方法，这样锁就进入“locked”状态。每次只有一个线程可以获得锁。如果当另一个线程试图获得这个锁的时候，就会被系统变为“blocked”状态，直到那个拥有锁的线程调用锁的release() （释放）方法，这样锁就会进入“unlocked”状态。“blocked”状态的线程就会收到一个通知，并有权利获得锁。如果多个线程处于“blocked”状态，所有线程都会先解除“blocked”状态，然后系统选择一个线程来获得锁，其他的线程继续沉默（“blocked”）。

import threading
mylock = threading.RLock()
class mythread(threading.Thread)
    ...
    def run(self ...):
        ...     #此处 不可以 放置修改共享数据的代码
        mylock.acquire()
        ...     #此处 可以 放置修改共享数据的代码
        mylock.release()
        ...     #此处 不可以 放置修改共享数据的代码

    我们把修改共享数据的代码称为“临界区”，必须将所有“临界区”都封闭在同一锁对象的acquire()和release()方法调用之间。

    锁只能提供最基本的同步级别。有时需要更复杂的线程同步，例如只在发生某些事件时才访问一个临界区（例如当某个数值改变时）。这就要使用“条件变量”。

    条件变量用threading.Condition类创建

    mycondition = threading.Condition()

    条件变量是如何工作的呢？首先一个线程成功获得一个条件变量后，调用此条件变量的wait()方法会导致这个线程释放这个锁，并进入“blocked”状态，直到另一个线程调用同一个条件变量的notify()方法来唤醒那个进入“blocked”状态的线程。如果调用这个条件变量的notifyAll()方法的话就会唤醒所有的在等待的线程。

    如果程序或者线程永远处于“blocked”状态的话，就会发生死锁。所以如果使用了锁、条件变量等同步机制的话，一定要注意仔细检查，防止死锁情况的发生。对于可能产生异常的临界区要使用异常处理机制中的finally子句来保证释放锁。等待一个条件变量的线程必须用notify()方法显式的唤醒，否则就永远沉默。保证每一个wait()方法调用都有一个相对应的notify()调用，当然也可以调用notifyAll()方法以防万一。

# Producer thread
class Producer(threading.Thread):
    def __init__(self, threadname, queue):
        threading.Thread.__init__(self, name = threadname)
        self.sharedata = queue
    def run(self):
        for i in range(20):
            print self.getName(),'adding',i,'to queue'
            self.sharedata.put(i)
            time.sleep(random.randrange(10)/10.0)
        print self.getName(),'Finished'

# Consumer thread
class Consumer(threading.Thread):
    def __init__(self, threadname, queue):
        threading.Thread.__init__(self, name = threadname)
        self.sharedata = queue
    def run(self):
        for i in range(20):
            print self.getName(),'got a value:',self.sharedata.get()
            time.sleep(random.randrange(10)/10.0)
        print self.getName(),'Finished'

# Main thread
def main():
    queue = Queue()
    producer = Producer('Producer', queue)
    consumer = Consumer('Consumer', queue)

    print 'Starting threads ...'
    producer.start()
    consumer.start()

    producer.join()
    consumer.join()

    print 'All threads have terminated.'

if __name__ == '__main__':
    main()

    示例代码中实现了两个类：生产者类Producer和消费者类Consumer。前者在一个随机的时间内放入一个值到队列queue中然后显示出来，后者在一定随机的时间内从队列queue中取出一个值并显示出来。

    在python中如何创建一个线程对象

    如果你要创建一个线程对象，很简单，只要你的类继承threading.Thread，然后在__init__里首先调用threading.Thread的__init__方法即可

    import threading
    class mythread(threading.Thread):
        def __init__(self, threadname):
            threading.Thread.__init__(self, name = threadname)
        ....

    这才仅仅是个空线程，我可不是要他拉空车的，他可得给我干点实在活。很简单，重写类的run()方法即可，把你要在线程执行时做的事情都放到里面

    import threading
    import time
    class mythread(threading.Thread):
        def __init__(...):
            ....
        def run(self):
            for i in range(10):
                print self.getName, i
            time.sleep(1)

    以上代码我们让这个线程在执行之后每隔1秒输出一次信息到屏幕，10次后结束

    getName()是threading.Thread类的一个方法，用来获得这个线程对象的name。还有一个方法setName()当然就是来设置这个线程对象的name的了。

    如果要创建一个线程，首先就要先创建一个线程对象

    mythread1 = mythread('mythread 1')

    一个线程对象被创建后，他就处于“born”（诞生状态）

    如何让这个线程对象开始运行呢?只要调用线程对象的start()方法即可

    mythread1.start()

    现在线程就处于“ready”状态或者也称为“runnable”状态。

    奇怪吗？不是已经start了吗？为什么不称为“running”状态呢？其实是有原因的。因为我们的计算机一般是不具有真正并行处理能力的。我们所谓的多线程只是把时间分成片段，然后隔一个时间段就让一个线程执行一下，然后进入“sleeping ”状态，然后唤醒另一个在“sleeping”的线程，如此循环runnable->sleeping->runnable... ，只是因为计算机执行速度很快，而时间片段间隔很小，我们感受不到，以为是同时进行的。所以说一个线程在start了之后只是处在了可以运行的状态，他什么时候运行还是由系统来进行调度的。

    那一个线程什么时候会“dead”呢？一般来说当线程对象的run方法执行结束或者在执行中抛出异常的话，那么这个线程就会结束了。系统会自动对“dead”状态线程进行清理。

    如果一个线程t1在执行的过程中需要等待另一个线程t2执行结束后才能运行的话那就可以在t1在调用t2的join()方法

    ....
    def t1(...):
        ...
        t2.join()
        ...

    这样t1在执行到t2.join()语句后就会等待t2结束后才会继续运行。

    但是假如t1是个死循环的话那么等待就没有意义了，那怎么办呢？可以在调用t2的join()方法的时候给一个浮点数做超时参数，这样这个线程就不会等到花儿也谢了了。我等你10s，你不回来我还不允许我改嫁啊？:)

    def t1(...):
        ...
        t2.join(10)
        ...

    如果一个进程的主线程运行完毕而子线程还在执行的话，那么进程就不会退出，直到所有子线程结束为止，如何让主线程结束的时候其他子线程也乖乖的跟老大撤退呢？那就要把那些不听话的人设置为听话的小弟，使用线程对象的setDaemon()方法，参数为bool型。True的话就代表你要听话，我老大（主线程）扯呼，你也要跟着撤，不能拖后腿。如果是False的话就不用那么听话了，老大允许你们将在外军命有所不受的。需要注意的是setDaemon()方法必须在线程对象没有调用start()方法之前调用，否则没效果。

    t1 = mythread('t1')
    print t1.getName(),t1.isDaemon()
    t1.setDaemon(True)
    print t1.getName(),t1.isDaemon()
    t1.start()
    print 'main thread exit'

    当执行到 print 'main thread exit' 后，主线程就退出了，当然t1这个线程也跟着结束了。但是如果不使用t1线程对象的setDaemon()方法的话，即便主线程结束了，还要等待t1线程自己结束才能退出进程。isDaemon()是用来获得一个线程对象的Daemonflag状态的。

    如何来获得与线程有关的信息呢？

    获得当前正在运行的线程的引用

    running = threading.currentThread()

    获得当前所有活动对象（即run方法开始但是未终止的任何线程）的一个列表

    threadlist = threading.enumerate()

    获得这个列表的长度

    threadcount = threading.activeCount()

    查看一个线程对象的状态调用这个线程对象的isAlive()方法，返回1代表处于“runnable”状态且没有“dead”

    threadflag = threading.isAlive()

class Producer(threading.Thread):
    def __init__(self, threadname, queue):
        threading.Thread.__init__(self, name=threadname)
        self.sharedata = queue
    def run(self):
        for i in range(10):
            print self.getName(), 'adding', i, 'to queue'
            self.sharedata.put(i)
            time.sleep(random.randrange(10)/10.0)
        print self.getName(), 'Finished'
class Consumer(threading.Thread):
    def __init__(self, threadname, queue):
        threading.Thread.__init__(self, name=threadname)
        self.sharedata = queue
    def run(self):
        for i in range(10):
            print self.getName(), 'get a value', self.sharedata.get()
            time.sleep(random.randrange(10)/10.0)
        print self.getName(), 'Finished'
def main():
    queue = Queue()
    producer = Producer('Producer', queue)
    consumer = Consumer('Consumer', queue)
    print 'Starting threads...'
    producer.start()
    consumer.start()
   
    producer.join()
    consumer.join()
    print 'All threads have terminated.'
   
if __name__ == '__main__':
    main()

如何来获得与线程有关的信息呢？

获得当前正在运行的线程的引用

running = threading.currentThread()

获得当前所有活动对象（即run方法开始但是未终止的任何线程）的一个列表

threadlist = threading.enumerate()

获得这个列表的长度

threadcount = threading.activeCount()

查看一个线程对象的状态调用这个线程对象的isAlive()方法，返回1代表处于“runnable”状态且没有“dead”

threadflag = threading.isAlive()

1.   使用
    import MySQLdb
1.1.   连接
    conn =   MySQLdb.Connection(host, user, password, dbname)
1.2.   选择数据库，如果上面没有指定数据库，则使用此方法指定！
    conn.select_db(’database name’)
1.3.   获得cursor
    cur =   conn.cursor()
1.4.   cursor位置设定
    cur.scroll(int, mode)
    mode可为相对位置或者绝对位置，分别为relative和absolute。
1.5.   select
    cur.execute(‘select clause’)
    例如
    cur.execute(‘select * from mytable’)

    row = cur.fetchall()
    或者：
    row1 = cur.fetchone()
1.6.   insert
    cur.execute(‘inset clause’)
    例如
    cur.execute("insert into user (Name, Password) values ('maggie','12345')")
    conn.commit()

1.7.   update
    cur.execute(‘update  clause’)
    例如
    cur.execute("update user set Name = 'eric chau' where id = 1")
    conn.commit()

1.8.   delete
    cur.execute(‘delete  clause’)
    例如
    cur.execute("delete from user where id = 1")
    conn.commit()


完整代码：

from MySQLdb import Connect

def conn():
    #conn = Connect('localhost','root','root')
    #conn.select_db('eric')
    conn = Connect('localhost','root','root','eric')
    cur = conn.cursor()
    cur.execute('select * from user')
    cur.scroll(0)
    row1 = cur.fetchone()
    print 'id:', row1[0]
    print 'name:', row1[1]
    print 'password:', row1[2]
    #cur.execute("insert into user (Name, Password) values ('maggie','12345')")
    #cur.execute("update user set Name = 'eric chau' where id = 1")
    cur.execute("delete from user where id = 11")
    conn.commit()
if __name__=='__main__':
    conn()