正则表达式

网络编程

因特网客户端编程

因特网客户端简介

文件传输

文件传输因特协议

在当下，HTTP,FTP,scp/rsync的应用仍然广泛。

Python和FTP

ftplib.FTP类

客户端FTP程序实例

#! /usr/bin/env python
# coding: utf-8
import ftplib
import os
import socket
HOST = 'ftp.mozilla.org'
DIRN = 'pub/mozilla.org/webtools'
FILE = 'bugzilla-LATEST.tar.gz'
def main():
    try:
        f = ftplib.FTP(HOST)
    except (socket.error, socket.gaierror) as e:
        print("ERROR: can't reach '%s' " % HOST)
        return
    print("*** Connected to host '%s'" % HOST)
    try:
        f.login()
    except ftplib.error_perm:
        print("ERROR: can't login anonymously")
        f.quit()
        return
    print("*** Logged in as 'anonymous")
    try:
        f.cwd(DIRN)
    except ftplib.error_perm:
        print("ERROR: can't CD to '%s" % DIRN)
        f.quit()
        return
    print("*** Change to '%s' folder" % DIRN )
    try:
        f.retrbinary("RETR %s" % FILE, open(FILE, 'wb').write())
    except ftplib.error_perm:
        print("ERROR: can't read file '%s'" % FILE)
        os.unlink(FILE)
    else:
        print("*** Download '%s' to CWD" % FILE)
        f.quit()
if __name__ == '__main__':
    main()

Ftp的其他内容

• 命令行客户端程序
• GUI客户端程序
• Web浏览器
• 自定义应用程序

网络新闻

Usenet与新闻组

网络新闻传输协议

NNTP

Python和NNTP

有一个nntplib库和一个需要实例化的nntplib.NNTP类

电子邮件

电子邮件系统组件和协议

发送电子邮件

• SMTP、ESMTP、LMTP

• MTA

  一些实现SMTP的MTA

  • 开源
    • Sendmail
    • Postfix
    • Exim
    • qmail
  • 商业
    • Microsoft Exchange
    • Lotus Notes Domino Mail Server

Python和SMTP

有一个smtplib模块和一个需要实例化的smtplib.SMTP类

smtplib.SMTP类方法

接收电子邮件

POP和IMAP

Python和POP3

导入poplib并实例化poplib.POP3

多线程编程

简介、动机

线程和进程

线程和Python

全局解释器锁

对Pyton虚拟机的访问是由*全局解释器锁（GIL）*控制的。在多线程环境中，Python虚拟机将按照正面所述折方式执行

1. 设置GIL
2. 切换进一个线程去运行
3. 执行正面的操作这一
   1. 指定数量的字节码指令
   2. 线程主动让出控制权（可以调用time.sleep(0)来完成）
4. 把线程设置回睡眠状态（切换出线程）
5. 解锁GIL
6. 重复上述步骤

可查看Python/ceval.c文件

退出线程

当一个线程完成函数的执行时，它就会退出。另外，还可以通过调用诸如thread.exit()之类的退出函数，或者sys.exit()之类的退出Python进程的标准方法，变或者抛出SystemExit异常，来使线程退出。 不过你不能直接“终止”一个线程。 主线程应该做一个好的管理者，负责了解每个单独的线程需要执行什么，每个派生的线程需要哪些数据或参数，这些线程执行守后会提供什么结果。这样，主线程就可以收集每个线程的相关介绍，然后汇兑成一个有意义的最终的结果。

在Python中使用线程

Python虽然支持多线程编程，但是还需要取决于它所运行的操作系统。

不使用线程的情况

？？？

Python的threading模块

避免使用thread

• theading模块更加先进，有更好的线程支持
• 并且thead模块中的一些属性会和threading模块有冲突。
• 低级别的thread模块拥有的同步原语很少（实际上只有一个），而threading模块有很多。
• thread对于进程何时退出没有控制。当主线程结束时，所有其他线程也都强制结束，不会发出警告或者进行适当的清理。
• thread不支持守护线程。

thread模块

thread模块除了提供派生线程外，还提供了基本的同步数据结构，称为锁对象（lock object, 也叫原语锁、简单锁、互斥锁、互斥和二进制信号量）核心函数： start_new_thread() 它的参数包括函数（对象）、函数的参数以及可选的关键参数。 e.g.

#! /usr/bin/env python
import thread
from time import sleep, ctime
def loop0():
    print('start loop 0 at : ', ctime())
    sleep(4)
    print('loop 0 done at: ', ctime())

def loop1()：
    print('start loop 1 at: ', ctime())
    sleep(2)
    print('loop 1 end at : ', ctime())

def main():
    print('starting at: ', ctime())
    thread.start_new_thread(loop0, ())
    thread.start_new_thread(loop1, ())
    sleep(6)
    print('all DONE at: ', ctime())

if __name__ == '__main__':
    main()

start_new_thread()必须包含开始的两个参数， 即使要执行的函数不需要参数，也需要传递一个空元组。 sleep(6)的作用是防止主线程执行完成后导致两个子线程异常终止。可是这样肯定不是最好的办法，我们不能确定子函数需要多长时间执行。所以需要引入锁。 e.g.

#！/usr/bin/env python3
# coding: utf-8
import thread
from time import sleep, ctime
loops = [4, 2]
def loop(nloop, nsec, lock):
    print('start loop', nloop, ' at: ', ctime())
    sleep(nsec)
    print('loop ', nloop, 'done at: ', ctime())
    lock.release()

def main():
    print('start at: ', ctime())
    locks = []
    nloops = range(len(loops))

    for i in nloops:
        lock = thread.allocate_lock()
        lock.acquire()
        locks.append(lock)

    for i in nloops:
        thread.start_new_thread(loop, (i, loops[i], locks[i]))

    for i in nloops:
        while locks[i].locked():pass

    print 'all DONE at: ', citme()

if __name__ == '__main__':
    main()

theading 模块

threading模块中所有可用对象的列表

• 守护线程

  避免使用thread模块的另一个原因是该模块不支持守护线程。 threading模块支持守护线程，其工作方式是：守护线程一般是一个等待客户端请求服务的服务器，如果没有客户端请求，守护线程就是空闲的。如果把一个线程设置成守护线程，就表示这个线程是不重要的，进程退出时不需要等待这个线程执行完成。要将一个线程设置为守护 线程，需要 在启动线程之前执行如下赋值语句：

  thread.daemon = True

  同样，要检查线程的守护状态，也只需要检查这个值即可。

Thread类

Thread对象的属性

Thread对象的方法

• 创建线程的方法

  • 创建 Thread的实例 ，传给它一个函数
  • 创建Thread的实例，传给它一个可调用的类实例
  • 派生Thread的子类，并创建子类的实例

  • 创建Thread的实例，传给它一个函数

    #! /usr/bin/env python
    import threading
    from time import sleep, ctime
    loops = [4, 2]
    def loop(nloop, nsec):
        print('start loop', nloop, ' at:', ctime())
        sleep(nsec)
        print('loop ', nloop, 'done at:', ctime())
    
    def main():
        print('start at；', ctime())
        threads = []
        nloops = range(len(loops))
    
        for i in nloops:
            t = threading.Thread(target=loop, args=(i, loops[i]))
            threads.append(t)
    
        for i in nloops:
            threads[i].start()
    
        for i in nloops:
            threads[i].join()
    
        print('all DONE at:', ctime())
    
    if __name__ == '__main__':
        main()
    

  • 创建Thread的实例，传给它一个可调用的类实例

    #! /usr/bin/env python
    import threading
    from time import sleep, ctime
    loops = [4, 2]
    class ThreadFunc():
        def __init__(self, func, args, name=''):
            self.name = name
            self.func = func
            self.args = args
    
        def __call__(self):
            self.func(*self.args)
    def loop(nloop, nsec):
        print('start loop', nloop, ' at:', ctime())
        sleep(nsec)
        print('loop ', nloop, 'done at:', ctime())
    
    def main():
        print('start at；', ctime())
        threads = []
        nloops = range(len(loops))
    
        for i in nloops:
            t = threading.Thread(target=ThreadFunc(loop, (i, loops[i]), loop.__name__))
            threads.append(t)
    
        for i in nloops:
            threads[i].start()
    
        for i in nloops:
            threads[i].join()
    
        print('all DONE at:', ctime())
    
    if __name__ == '__main__':
        main()
    

  • 派生Thread的子类，并创建子类的实例

    #! /usr/bin/env python
    import threading
    from time import sleep, ctime
    loops = [4, 2]
    class MyThread(threading.Thread):
        def __init__(self, func, args, name=''):
            threading.Thread.__init__(self)
            self.name = name
            self.func = func
            self.args = args
    
        def run(self):
            self.func(*self.args)
    def loop(nloop, nsec):
        print('start loop', nloop, ' at:', ctime())
        sleep(nsec)
        print('loop ', nloop, 'done at:', ctime())
    
    def main():
        print('start at；', ctime())
        threads = []
        nloops = range(len(loops))
    
        for i in nloops:
            t = MyThread(loop, (i, loops[i]), loop.__name__)
            threads.append(t)
    
        for i in nloops:
            threads[i].start()
    
        for i in nloops:
            threads[i].join()
    
        print('all DONE at:', ctime())
    
    if __name__ == '__main__':
        main()
    

threading 模块的其他函数

单线程和多线程执行对比

多线程实践

引入线程

同步原语

锁/互斥信号量

锁示例

锁有两种状态：

• 锁定
• 未锁定

两个函数：

• 获得锁: lock.acquire()
• 释放锁: lock.release()

使用上下文管理 2.5以后可以使用with语句，而不再调用锁的acquire()和release()而进一步简化代码。

信号量

信号量是一个计数器，当资源消耗时递减，当资源释放时递增。你可以认为信号量代表它们的资源可用或不可用。 e.g.

#! /usr/bin/env python
# coding: utf-8
from atexit import register
from random import randrange
from threading import BoundedSemaphore, Lock, Thread
from time import sleep, ctime
lock = Lock()
MAX = 5
candytray = BoundedSemaphore(MAX)
def refill():
    lock.acquire()
    print('Refilling candy...',)
    try:
        candytray.release()
    expect ValueError:
        print('full, skipping')
    else:
        print('OK')
    lock.release()

def by():
    lock.acquire()
    print('Buying candy...')
    if candytray.acquire(False):
        print('OK')
    else:
        print('empty, skipping')
    lock.release()

def producer(loops):
    for i in xrange(loops):
        refill()
        sleep(randrange(3))

def consumer(loops):
    for i in xrange(loops):
        buy()
        sleep(randrange(3))

def _main():
    print('starting at: ', ctime())
    nloops = randrange(2, 6)
    print('The Candy Machine (full with %d bars)!' % MAX)
    Thread(target=consumer, args=(randrange(
        nloops, nlops+MAX+2),)).start()
    Thread(target=producer, args=(nloops,)).start()

@register
def _atexit():
    print('all DONE at:', ctime())

if __name__ == '__main__':
    _main()

生产者-消费者问题和Queue/queue模块

常用属性

常用异常

常用方法

线程的替代方案

subprocess 模块

这是派生进程的主要替代方案，可以单纯地执行任务，或者通过标准文件（stdin, stdout, stderr)进行进程间通信。

multiprocessing模块

2.6引入，允许为多核或多CPU派生进程，其接口与threading模块相似。该模块同样也包括在共享任务的进程间传输数据的多种方式。

concurrent.futures模块

e.g.

concurrent.futures import ThreadPoolExecutor
def __main():
    print('At ', ctime(), ' on Amazon...')
    with ThreadPoolExecutor(3) as executor:
        for isbn in ISBs:
            executor.submit(_showRanking, isbn)
    print('all DONE at:', ctime())

e.g. 高级任务管理

#! /usr/bin/env python
from concurrent.futures improt ThreadPoolExecutor
from re import compile
from time improt ctime
from urllib.request import urlopen as uopen
REGEX = compile(b'#([\d,]+) in Books ')
AMZN = 'http://amazon.com/dp/'
ISBNs = {
    '0135648956': 'Core Python Programming',
    '0135648956': 'Core Python Programming',
    '0135648956': 'Core Python Programming',
}
def getRanking(isbn):
    with uopen('{0}{1}' .format(AMZN, isbn)) as page:
        return str(REGEX.findall(page.read())[0], 'utf-8')

def _main():
    print('At', ctime(), ' on Amazon...')
    with ThreadPoolExecutor(3) as executor:
        for isbn, ranking in zip(
                ISBNs, executor.map(getRanking, ISBNs)):
            print('- %r ranked &s' % (ISBNs[isbn], ranking))
        print('all DONE at: ', ctime())

        )

GUI编程

数据库编程

简介

持久化存储

存储机制：文件，数据库系统，混合类型。

数据库基本操作和SQL

• 底层存储数据库通常使用文件系统作为基本的持久化存储。
• 用户接口 SQL
• 数据库一个关系 数据库管理系统通常可以管理多个数据库
• 组件数据库存储可以抽象为一张表
• SQL 数据库命令和查询操作是通过SQL语句提交给数据库的。

数据库和Python

Python的DB-API

模块属性

DB-API标准要求必须提供下文列出的功能和属性

• 数据库参数风格：

  参数风格	描述	示例
  numeric	数值位置风格	where name = :1
  named	命名风格	where name = :name
  pyformat	Python字典printf()格式转换	where name = %(name)s
  qmark	问号风格	where name = ?
  format	ANSIC的printf()格式转换	where name = %s

• connect() connect()函数通过Connection对象访问数据库。兼容模块必须实现 connect()函数，该函数创建并返回一个Connection对象。 connect()函数属性：

  参数	描述
  user	用户名
  password	密码
  host	主机名
  database	数据库名
  dsn	数据源名

Connection对象

Connection对象方法：

Cursor对象

游标可以让用户提交数据库命令，并获得查询的结果行。 Cursor对象属性

ORM

考虑对象而不是SQL 目前最知名的Python ORM是SQLAlchemy和SQLObject。

SQLAlchemy常用方法：

• filter_by():将指定列的什作为关键字参数以获取查询结果。
• filter()：与fliter_by()类似，不过更加灵活，还可以使用表达式。比如：query.filter_by(userid=1)与query.filter(User.userid ==1)相同
• order_by()
• limit()
• offset()
• all()
• one()
• first()
• join()
• update()
• delete()

非关系数据库

Web客户端和服务器

Python Web客户端工具

urllib模块/包

• urllib.request.urlopen() 打开一个给定的URL字符串表示的Web连接

  urlopen (urlstr, postQueryData=None)

  一旦连接成功，urlopen将会返回一个文件类型对象。 urlopen()文件类型对象的方法：

• urllib.request.urlretrieve() 用于下载完整的HTML，或对象文件。

  urlretrieve(url, filename=None, reporthook=None, data=None)

• quote()

• unquote()

• urlencode()

• …

Web编程：CGI和WSGI

CGI：Common Gateway Interface 通用网关掊 WSGI：Web Server Gateway Interface Web服务器网关接口

Web框架：Django

• 安装

  pip install django

• 创建项目

  django-admin.exe startproject project_name

• 创建应用

  python ./manage.py startapp app_name

• 创建POJO对象

• 创建表

  python ./manage.py migrate

python 应用shell

在Django中使用Python shell

python ./manage.py shell

安装应用

在settings.py的INSTALLED_APPS中添加app_name

Python2与Python3的区别

• print
  • 在python2中它是一条语句 print …
  • 在python3中它成为了一个内置函数：print(’…')
• input
  • python2中使用raw_input()
  • python3中使用input()
• exception
  • python2:except Exception, instance
  • python3:except Exception as instance