Python学习摘录（下）

常用内建模块

1：collections模块：集合模块，提供了许多有用的集合类。

namedtuple

namedtuple是一个函数，它用来创建一个自定义的tuple对象，并且规定了tuple元素的个数，并可以用属性而不是索引来引用tuple的某个元素。

这样一来，我们用namedtuple可以很方便地定义一种数据类型，它具备tuple的不变性，又可以根据属性来引用，使用十分方便。

>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(1, 2)
>>> p.x
1
>>> p.y
2

deque：为了高效实现插入和删除操作的双向列表，适合用于队列和栈。

deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。

>>> from collections import deque
>>> q = deque(['a', 'b', 'c'])
>>> q.append('x')
>>> q.appendleft('y')

defaultdict：使用`dict`时，如果引用的Key不存在，就会抛出`KeyError`。如果希望key不存在时，返回一个默认值，就可以用`defaultdict`

 dd = defaultdict(lambda: 'N/A')
dd['key2'] # key2不存在，返回默认值 'N/A'

OrderedDict：保持Key的顺序，`OrderedDict`的Key会按照插入的顺序排列，不是Key本身排序。

 od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> od # OrderedDict的Key是有序的
OrderedDict([('a', 1), ('b', 2), ('c', 3)])

Counter：一个简单的计数器。

统计字符出现的个数：

>>> from collections import Counter
>>> c = Counter()
>>> for ch in 'programming':
...     c[ch] = c[ch] + 1

2：hashlib

Python的hashlib提供了常见的摘要（散列）算法，如MD5，SHA1等等。

它通过一个函数，把任意长度的数据转换为一个长度固定的数据串（通常用16进制的字符串表示）。

md5使用：

import hashlib
 
md5 = hashlib.md5()//创建md5实例
md5.update('how to use md5 in python hashlib?')//使用md5对字符串加密
print md5.hexdigest()//得到md5加密后的字符串

sha1使用：

import hashlib
 
sha1 = hashlib.sha1()//创建sha1实例
sha1.update('how to use sha1 in ')//加密
print sha1.hexdigest()//获取加密后字符串

摘要算法的正确使用：使用唯一性内容+需要加密的内容+混淆性内容作为数据库存储的内容。

通过对原始口令加一个复杂字符串，俗称“加盐”。但是如果加密内容一致，加盐又一致，则会出现相同的存储内容。所以在此基础上再加上唯一性的内容，比如用户名。

db[username] = get_md5(password + username + 'the-Salt')

3：itertools

Python的内建模块itertools提供了非常有用的用于操作迭代对象的函数。

几个“无限”迭代器：

count(n)会创建一个无限的迭代器，从n开始一直迭代下去，永不停止。

cycle(str)会把传入的一个序列无限重复迭代下去。

repeat(char,num)负责把一个元素无限重复下去，不过如果提供第二个参数就可以限定重复次数

无限序列虽然可以无限迭代下去，但是通常我们会通过takewhile()等函数根据条件判断来截取出一个有限的序列：

>>> natuals = itertools.count(1)//创建一个无限迭代器
 
>>> ns = itertools.takewhile(lambda x: x <= 10, natuals)//遍历无限迭代器的内容，从中提取符合lambda表达式的内容

操作迭代器的几个函数：

chain()可以把一组迭代对象串联起来，形成一个更大的迭代器：

for c in itertools.chain('ABC', 'XYZ'):
    print c
# 迭代效果：'A' 'B' 'C' 'X' 'Y' 'Z'

groupby()把迭代器中相邻的重复元素挑出来放在一起。

imap()可以作用于无穷序列，并且，如果两个序列的长度不一致，以短的那个为准。当你调用imap()时，并没有进行任何计算，必须用for循环对r进行迭代，才会在每次循环过程中计算出下一个元素。

同理，ifilter()就是filter()的惰性实现。

4：XML操作模块

操作XML有两种方法：DOM和SAX。DOM会把整个XML读入内存，解析为树，因此占用内存大，解析慢，优点是可以任意遍历树的节点。SAX是流模式，边读边解析，占用内存小，解析快，缺点是我们需要自己处理事件。

正常情况下，优先考虑SAX，因为DOM实在太占内存。

在Python中使用SAX解析XML非常简洁，通常我们关心的事件是start_element，end_element和char_data，准备好这3个函数，然后就可以解析xml了。

from xml.parsers.expat import ParserCreate
 
#定义三个事件
class DefaultSaxHandler(object):
    def start_element(self, name, attrs):
        print('sax:start_element: %s, attrs: %s' % (name, str(attrs)))
 
    def end_element(self, name):
        print('sax:end_element: %s' % name)
 
    def char_data(self, text):
        print('sax:char_data: %s' % text)
 
xml = r'''<?xml version="1.0"?>
<ol>
    <li><a href="/python">Python</a></li>
    <li><a href="/ruby">Ruby</a></li>
</ol>
'''
 
handler = DefaultSaxHandler()
parser = ParserCreate()
parser.returns_unicode = True
parser.StartElementHandler = handler.start_element
parser.EndElementHandler = handler.end_element
parser.CharacterDataHandler = handler.char_data
parser.Parse(xml)

如何生成XML呢？最简单也是最有效的生成XML的方法是拼接字符串：

L = []
L.append(r'<?xml version="1.0"?>')
L.append(r'<root>')
L.append(encode('some & data'))
L.append(r'</root>')
return ''.join(L)

5：HTMLParser

如何解析HTML呢？

from HTMLParser import HTMLParser
from htmlentitydefs import name2codepoint
 
class MyHTMLParser(HTMLParser):
 
    def handle_starttag(self, tag, attrs):
        print('<%s>' % tag)
 
    def handle_endtag(self, tag):
        print('</%s>' % tag)
 
    def handle_startendtag(self, tag, attrs):
        print('<%s/>' % tag)
 
    def handle_data(self, data):
        print('data')
 
    def handle_comment(self, data):
        print('<!-- -->')
 
    def handle_entityref(self, name):
        print('&%s;' % name)
 
    def handle_charref(self, name):
        print('&#%s;' % name)

6：强大的第三方图形处理模块——PIL

首先，要安装PIL。

然后，就行import相关模块，调用模块内的函数进行图形处理了。

网络编程

TCP/IP——Socket通信

1：客户端通信

# 导入socket库:
import socket
# 创建一个socket:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 建立连接:
s.connect(('域名', 端口))
 
#发送数据

s.send('内容')

# 每次最多接收1k字节:
 d = s.recv(1024)

# 关闭连接:
s.close()

创建Socket时，AF_INET指定使用IPv4协议，如果要用更先进的IPv6，就指定为AF_INET6。SOCK_STREAM指定使用面向流的TCP协议。

2：服务端通信

#首先，创建一个基于IPv4和TCP协议的Socket：
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#然后绑定监听的地址和端口
# 监听端口:
s.bind(('IP地址',端口))
#调用listen()方法开始监听端口，传入最大监听数
s.listen(5)
#通过一个永久循环来接受来自客户端的连接，accept()会等待并返回一个客户端的连接
 
while True:
    # 接受一个新连接:
    sock, addr = s.accept() #accept方法返回一个含有两个元素的元组(connection,address)
    # 创建新线程来处理TCP连接:
    t = threading.Thread(target=任务函数, args=(sock, addr))
    t.start()
 
 data = sock.recv(1024)#接收内容
 sock.send('Hello, %s!' % data)#发回内容
 sock.close() #关闭socket

UDP编程

使用UDP协议时，不需要建立连接，只需要知道对方的IP地址和端口号，就可以直接发数据包。

服务端

#创建服务端socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)#SOCK_DGRAM指定了这个Socket的类型是UDP
# 绑定端口:
s.bind(('127.0.0.1', 9999))
 
#无需监听端口，直接接收来自任何客户端的数据
while True:
    # 接收数据：recvfrom()方法返回数据和客户端的地址与端口，这样，服务器收到数据后，直接调用sendto()就可以把数据用UDP发给客户端。
    data, addr = s.recvfrom(1024)
    print 'Received from %s:%s.' % addr
    s.sendto('Hello, %s!' % data, addr)

客户端

不需要调用connect()，直接通过sendto()给服务器发数据。

#创建socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
for data in ['Michael', 'Tracy', 'Sarah']
    # 发送数据
    s.sendto(data, ('服务器IP',端口))
    # 接收数据
    print s.recv(1024)
s.close()

数据库

操作Mysql：

# 导入MySQL驱动
>>> import mysql.connector
>>> conn = mysql.connector.connect(user='数据库账户', password='密码', database='数据库名', use_unicode=True)
>>> cursor = conn.cursor()//创建一个游标
# 创建user表
>>> cursor.execute('create table user (id varchar(20) primary key, name varchar(20))')//执行SQL语句
# 插入一行记录，注意MySQL的占位符是%s:
>>> cursor.execute('insert into user (id, name) values (%s, %s)', ['', 'Michael'])
>>> cursor.rowcount //获取语句执行结果
1
# 提交事务:
>>> conn.commit()
>>> cursor.close()
# 运行查询:
>>> cursor = conn.cursor()
>>> cursor.execute('select * from user where id = %s', ('',))
>>> values = cursor.fetchall()//查询所有
>>> values
[(u'', u'Michael')]
# 关闭Cursor和Connection:
>>> cursor.close()
True
>>> conn.close()

Python中的ORM框架：SQLAlchemy

# 导入:
from sqlalchemy import Column, String, create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base
 
# 创建对象的基类:
Base = declarative_base()
 
# 定义User对象:
class User(Base):
    # 表的名字:
    __tablename__ = 'user'
 
    # 表的结构:
    id = Column(String(20), primary_key=True)
    name = Column(String(20))
 
# 初始化数据库连接:
engine = create_engine('mysql+mysqlconnector://root:password@localhost:3306/test')
# 创建DBSession类型:
DBSession = sessionmaker(bind=engine)
 
# 创建session对象:
session = DBSession()
# 创建新User对象:
new_user = User(id='', name='Bob')
# 添加到session:
session.add(new_user)
# 提交即保存到数据库:
session.commit()
# 关闭session:
session.close()
 
# 创建Session:
session = DBSession()
# 创建Query查询，filter是where条件，最后调用one()返回唯一行，如果调用all()则返回所有行:
user = session.query(User).filter(User.id=='').one()
# 打印类型和对象的name属性:
print 'type:', type(user)
print 'name:', user.name
# 关闭Session:
session.close()

Web开发

PythonWeb提供了一套接口：WSGI：Web Server Gateway Interface。它只要求Web开发者实现一个函数，就可以响应HTTP请求。

函数接收两个参数：

environ：一个包含所有HTTP请求信息的dict对象；
start_response：一个发送HTTP响应的函数。start_response()函数接收两个参数，一个是HTTP响应码，一个是一组list表示的HTTP Header，每个Header用一个包含两个str的tuple表示。

使用web框架

除了Flask，常见的Python Web框架还有：

Django：全能型Web框架；
web.py：一个小巧的Web框架；
Bottle：和Flask类似的Web框架；
Tornado：Facebook的开源异步Web框架