#-*- encoding:utf-8 -*-
from numpy import *
def loadDataSet():
    postingList=[['my','dog','has','flea','problems','help','please'],
                 ['maybe','not','take','him','to','dog','park','stupid',],
                 ['my','dalmation','is','so','cute','I','love','him'],
                 ['stop','posting','stupid','worthless','garbage'],
                 ['mr','licks','ate','my','steak','how','to','stop','him'],
                 ['quit','buying','worthless','dog','food','stupid']]
    #1 代表侮辱性文字，0代表正常言论
    classVec=[0,1,0,1,0,1]  
    return postingList,classVec
def createVocabList(dataSet):
# 取唯一值
    vocabSet=set([])
    for document in dataSet:
        vocabSet=vocabSet|set(document)
    return list(vocabSet)
def setOfWords2Vec(vocabList,inputSet):
    # 参数1唯一值  当前列表参数2原值，出现在当前词组出现在总词库中的索引
    returnVec=[0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)]=1
        else:
            print "the word %s is not in my Vocablary!"%word
    return returnVec
def trainNB0(trainMatrix,trainCategory):  
    #只针对二分类问题
    numTrainDocs=len(trainMatrix)  # 统计有几个训练用词组文档
    numWords=len(trainMatrix[0])  # 词库数量
    pAbusive=sum(trainCategory)/float(numTrainDocs)  # 侮辱性词组数量和词组数量的比值
    p0Num=ones(numWords);p1Num=ones(numWords)  #p0Num,p1Num等于总词库数量个1
    p0Denom=2.0;p1Denom=2.0
    for i in range(numTrainDocs):  # 以i遍历每个词组
        if trainCategory[i]==1:  # 如果是侮辱性词组
            p1Num+=trainMatrix[i]  # 每个词在总词库副本中的计数+1
            p1Denom+=sum(trainMatrix[i])  #侮辱性词组中单词的总数
        else:
            p0Num+=trainMatrix[i]  # 每个词在总词库中的计数+1
            p0Denom+=sum(trainMatrix[i])  # 非侮辱性词组中单词的总数
    p1Vect=log(p1Num/p1Denom)  # 侮辱性词在词库中的占比,避免下溢出，采取自然底数
    p0Vect=log(p0Num/p0Denom)  # 非侮辱词在词库中的占比
    return p0Vect,p1Vect,pAbusive
def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):
    p1=sum(vec2Classify*p1Vec)+log(pClass1)  # 出现词组的位置与总字库内词组向量相乘，加自然底数中侮辱性词库在词库中的占比
    p0=sum(vec2Classify*p0Vec)+log(1.0-pClass1)
    # 权重越大，说明可能性越高
    if p1>p0:
        return 1
    else:
        return 0
def testingNB():
    listOPosts,listClasses=loadDataSet()  # 原文档和词组是否为侮辱性词汇的定义
    myVocabList=createVocabList(listOPosts)  # 总词库，每个词都是唯一的
    trainMat=[]
    for postinDoc in listOPosts:  # 形成一个二维数组，内有每个在总词库，文档单词在库中的索引
        trainMat.append(setOfWords2Vec(myVocabList,postinDoc))
    p0V,p1V,pAb=trainNB0(array(trainMat),array(listClasses))  # 返回每个词组的侮辱性语言概率，非侮辱性语言概率，侮辱性语言再词库中所占比
    testEntry=['love','my','dalmation']#测试词汇
    thisDoc=array(setOfWords2Vec(myVocabList,testEntry))  # 添加测试词组,返回测试词组个总词库索引
    print testEntry,'classified as:',classifyNB(thisDoc, p0V, p1V, pAb)
    testEntry=['stupid','garbage']
    thisDoc=array(setOfWords2Vec(myVocabList,testEntry))
    print testEntry,'classified as:',classifyNB(thisDoc,p0V,p1V,pAb)
if __name__=='__main__':
    testingNB()

import cPickle as pickle  
# 序列化  
my_data= {"name":"Python","type":"Language"}  
fp = open("picklefile.dat","wb")  
pickle.dump(my_data, fp)  
fp.close  
  
# 反序列化  
fp = open("picklefile.dat", "rb")  
out = pickle.load(fp)  
```  
pickle模块的优点：  
1. 接口简单，容易使用。  
2. 存储格式有平台通用型，在Linux和Windouws都可以使用，兼容性好。  
3. 支持数据类型广泛，除了常规项，还包含能通过类的\__dict__或\__getstate__()方法返回的对象。  
4. pickle是可扩展的，对于不可序列化的对象，也可以通过特殊方法来返回示例在被pickle时的状态。  
5. 能够自动维护对象间的引用  
  
pickle模块的限制：  
* pickle不能保证操作的原子性。当错误发生时，可能部分数据已经被保存；如果对象处于深递归状态，那么可能超过python的最大递归深度，可以通过sys.setrecursionlimit()进行扩展。  
* pickle存在安全性问题，为乳清提供了可能。  
* pickle协议是python特定的，不同语言之间数据内容可能难以保障。  
  
简单来说，对于需要存储的对象，使用pickle，另外很重要的一点，**dat文件用pickle模块来读**。  
  
### 建议 45：序列化的另一个不错的选择 -- JSON  
cJson比python自身的json要快250倍  
JSON的优势：  
1. 使用简单，支持多种数据类型（集合、列表、字典、关联数组等等）  
2. 存储格式可读性更友好，易于修改  
3. 支持跨平台跨语言操作，所占空间更小  
4. 具有较强扩展性  
  
json的速度比pickle略慢。  
**json不支持序列化dateime**  
  
### 建议 46：使用 traceback 获取栈信息  
  
当发生异常，开发人员往往需要看到现场信息，trackback 模块可以满足这个需求，先列几个常用的：  
  
```python  
traceback.print_exc()   # 打印错误类型、值和具体的trace信息  
traceback.print_exception(type, value, traceback[, limit[, file]])  # 前三个参数的值可以从sys.exc_info()  
raceback.print_exc([limit[, file]])         # 同上，不需要传入那么多参数  
traceback.format_exc([limit])               # 同 print_exc()，返回的是字符串  
traceback.extract_stack([file, [, limit]])  # 从当前栈中提取 trace 信息  
```  
  
traceback 模块获取异常相关的数据是通过sys.exc_info()得到的，该函数返回异常类型type、异常value、调用和堆栈信息traceback组成的元组。  
  
同时 inspect 模块也提供了获取 traceback 对象的接口。  
  
### 建议 47：使用 logging 记录日志信息  
  
仅仅将信息输出到控制台是远远不够的，更为常见的是使用日志保存程序运行过程中的相关信息，如运行时间、描述信息以及错误或者异常发生时候的特定上下文信息。Python 提供 logging 模块提供了日志功能。  
  
常规日志设置:  
```python  
logging.basicConfig(  
            filename='%s.log' % self.table_name,  
            level=logging.DEBUG,  
            format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',  
            datefmt='%a, %d %b %Y %H:%M:%S')  
```  
logging是线程安全的，不支持多进程写入同一个子文件，对多个进程需要配置不同的日志文件。  
  
### 建议 48：使用 threading 模块编写多线程程序  
（python3中，使用threadpool线程池模块比较省心）  
由于 GIL 的存在，让 Python 多线程编程在多核处理器中无法发挥优势，但在一些使用场景下使用多线程仍然比较好，如等待外部资源返回，或建立反应灵活的用户界面，或多用户程序等。  
  
Python3 提供了两个模块：_thread和threading。_thread提供了底层的多线程支持，使用比较复杂，下面我们重点说说threading。  
  
Python 多线程支持用两种方式来创建线程：一种通过继承 Thread 类，重写它的run()方法；另一种是创建一个 threading.Thread 对象，在它的初始化函数__init__()中将可调用对象作为参数传入。  
  
threading模块中不仅有 Lock 指令锁，RLock 可重入指令锁，还支持条件变量 Condition、信号量 Semaphore、BoundedSemaphore 以及 Event 事件等。  
  
下面有一个比较经典的例子来理解多线程：
  
```python  
import threading  
from time import ctime,sleep  
  
def music(func):  
    for i in range(2):  
        print("I was listening to %s. %s" % (func,ctime()))  
        sleep(1)    # 程序休眠 1 秒  
  
def move(func):  
    for i in range(2):  
        print("I was at the %s! %s" % (func,ctime()))  
        sleep(5)  
  
threads = []  
t1 = threading.Thread(target=music,args=('爱情买卖',))  
threads.append(t1)  
t2 = threading.Thread(target=move,args=('阿凡达',))  
threads.append(t2)  
  
if __name__ == '__main__':  
    for t in threads:  
        t.setDaemon(True)   # 声明线程为守护线程  
        t.start()  
    #3  
    print("all over %s" % ctime())  
  
```  
  
以下是运行结果：  
  
```python  
I was listening to 爱情买卖. Tue Apr  4 17:57:02 2017  
I was at the 阿凡达! Tue Apr  4 17:57:02 2017  
all over Tue Apr  4 17:57:02 2017  
  
```  
  
分析：threading 模块支持线程守护，我们可以通过setDaemon()来设置线程的daemon属性，当其属性为True时，表明主线程的退出可以不用等待子线程完成，反之，daemon属性为False时所有的非守护线程结束后主线程才会结束，那运行结果为：  
  
```python  
I was listening to 爱情买卖. Tue Apr  4 18:05:26 2017  
I was at the 阿凡达! Tue Apr  4 18:05:26 2017  
all over Tue Apr  4 18:05:26 2017  
I was listening to 爱情买卖. Tue Apr  4 18:05:27 2017  
I was at the 阿凡达! Tue Apr  4 18:05:31 2017  
  
```  
继续修改代码，当我们在#3处加入t.join()，此方法能够阻塞当前上下文环境，直到调用该方法的线程终止或到达指定的 timeout，此时在运行程序：  
  
```python  
I was listening to 爱情买卖. Tue Apr  4 18:08:15 2017  
I was at the 阿凡达! Tue Apr  4 18:08:15 2017  
I was listening to 爱情买卖. Tue Apr  4 18:08:16 2017  
I was at the 阿凡达! Tue Apr  4 18:08:20 2017  
all over Tue Apr  4 18:08:25 2017  
  
```  
  
当我们把music函数的休眠时间改为 4 秒，再次运行程序：  
  
```python
I was listening to 爱情买卖. Tue Apr  4 18:11:16 2017  
I was at the 阿凡达! Tue Apr  4 18:11:16 2017  
I was listening to 爱情买卖. Tue Apr  4 18:11:20 2017  
I was at the 阿凡达! Tue Apr  4 18:11:21 2017  
all over Tue Apr  4 18:11:26 2017  
```  
此时我们就可以发现多线程的威力了，music虽然增加了 3 秒，然而总的运行时间仍然为 10 秒。  
  
### 建议 49：使用 Queue 使多线程编程更加安全  
（同47，使用threadingpool）  
线程间的同步和互斥，线程间数据的共享等这些都是涉及线程安全要考虑的问题。纵然 Python 中提供了众多的同步和互斥机制，如 mutex、condition、event 等，但同步和互斥本身就不是一个容易的话题，稍有不慎就会陷入死锁状态或者威胁线程安全。  
  
如何保证线程安全呢？我们先来看看 Python 中的 Queue 模块：  
  
* Queue.Queue(maxsize)：先进先出，maxsize 为队列大小，其值为非正数的时候为无限循环队列  
* Queue.LifoQueue(maxsize)：后进先出，相当于栈  
* Queue.PriorityQueue(maxsize)：优先级队列  
  
以上队列所支持的方法：  
  
* Queue.qsize()：返回近似的队列大小。当该值 > 0 的时候并不保证并发执行的时候 get() 方法不被阻塞，同样，对于 put() 方法有效。  
* Queue.empty()：队列为空的时候返回 True，否则返回 False  
* Queue.full()：当设定了队列大小的情况下，如果队列满则返回 True，否则返回 False  
* Queue.put(item[, block[, timeout]])：往队列中添加元素 item，block 设置为 False 的时候，如果队列满则抛出 Full 异常。如果 block 设置为 True，timeout 为 None 的时候则会一直等待直到有空位置，否则会根据 timeout 的设定超时后抛出 Full 异常  
* Queue.put_nowait(item)：等于 put(item, False).block 设置为 False 的时候，如果队列空则抛出 Empty 异常。如果 block 设置为 True、timeout 为 None 的时候则会一直等到有元素可用，否则会根据 timeout 的设定超时后抛出 Empty 异常  
* Queue.get([block[, timeout]])：从队列中删除元素并返回该元素的值  
* Queue.get_nowait()：等价于 get(False)  
* Queue.task_done()：发送信号表明入列任务已经完成，经常在消费者线程中用到  
* Queue.join()：阻塞直至队列中所有的元素处理完毕  
首先 Queue 中的队列和 collections.deque 所表示的队列并不一样，前者用于不同线程之间的通信，内部实现了线程的锁机制，后者是数据结构上的概念，支持 in 方法。  
  
Queue 模块实现了多个生产者多个消费者的队列，当多线程之间需要信息安全的交换的时候特别有用，因此这个模块实现了所需要的锁原语，为 Python 多线程编程提供了有力的支持，它是线程安全的。  
  
先来看一个简单的例子：  
```python  
import os  
import Queue  
import threading  
import urllib2  
  
class DownloadThread(threading.Thead):  
  
    def __init__(self, queue):  
        threading.Thread.__init__(self)  
        self.queue = queue  
  
    def run(self):  
        while True:  
            url = self.queue.get()  
            print('{0} begin download {1}...'.format(self.name, url))  
            self.download_file(url)  
            self.queque.task_done()  
            print('{0} download completed!!!'.format(self.name))  
  
    def download_file(self, url):  
        urlhandler = urllib2.urlopen(url)  
        fname = os.path.basename(url) + '.html'  
        with open(fname, 'wb') as f:  
            while True:  
                chunk = urlhandler.read(1024)  
                if not chunk: break  
                f.write(chunk)  
  
if __name__ == '__main__':  
    urls = ['http://wiki.python.org/moin/WebProgramming',  
            'https://www.createspace.com/3611970',  
            'http://wiki.python.org/moin/Documentation'  
    ]  
    queue = Queue.Queue()  
    for i range(5):  
        t = DownloadThread(queue)  
        t.setDaemon(True)  
        t.start()  
    for url in urls:  
        queue.put(url)  
    queue.join()  
  
```  
  
## 第 5 章 设计模式  
### 建议 50：利用模块实现单例模式  
单例模式可以保证徐彤中一个类只有一个实例且该实例易被外界访问，常用来使用XxxManager之类的功能。  
  
满足单例模式的 3 个需求：  
  
* 只能有一个实例  
* 必须自行创建这个实例  
* 必须自行向整个系统提供这个实例  
  
模块采用的其实是天然的单例的实现方式，在入口文件导入：  
* 所有的变量都会绑定到模块  
* 模块只初始化一次  
* import 机制是线程安全的，保证了在并发状态下模块也只是一个实例  
  
```python  
# World.py  
import Sun  
  
def run():  
    while True:  
        Sun.rise()  
        Sun.set()  
  
# main.py  
import World  
World.run()  
```  
  
此外，Borg模式可以创造任意数量实例，并保证状态共享。  
  
### 建议 51：用 mixin 模式让程序更加灵活  
模板方法模式就是在一个方法中定义一个算法的骨架，并将一些实现步骤延迟到子类中。模板方法可以使子类在不改变算法结构的情况下，重新定义算法中的某些步骤。  
  
```python  
class UseSimpleTeapot(object):  
    def get_teapot(self):  
        return SimpleTeapot()  
  
class UseKungfuTeapot(object):  
    def get_teapot(self):  
        return KungfuTeapot()  
  
class OfficePeople(People, UseSimpleTeapot): pass  
  
class HomePeople(People, UseSimpleTeapot): pass  
  
class Boss(People, UseKungfuTeapot): pass  
  
def simple_tea_people():  
    people = People()  
    people.__base__ += (UseSimpleTeapot,)  
    return people  
  
def coffee_people():  
    people = People()  
    people.__base__ += (UseCoffeepot,)  
  
def tea_and_coffee_people():  
    people = People()  
    people.__base__ += (UseSimpleTeapot, UserCoffeepot,)  
    return people  
  
def boss():  
    people = People()  
    people.__base__ += (KungfuTeapot, UseCoffeepot, )  
    return people  
  
```  
  
代码的原理在于每个类都有一个__bases__属性，它是一个元组，用来存放所有的基类，作为动态语言，Python 中的基类可以在运行中可以动态改变。所以当我们向其中增加新的基类时，这个类就拥有了新的方法，这就是混入mixin。  
  
利用这个技术我们可以在不修改代码的情况下就可以完成需求：  
  
```python  
import mixins   # 把员工需求定义在 Mixin 中放在 mixins 模块  
  
def staff():  
    people = People()  
    bases = []  
    for i in config.checked():  
        bases.append(getattr(maxins, i))  
    people.__base__ += tuple(bases)  
    return people  
  
```  
### 建议 52：用发布订阅模式实现松耦合  
  
发布订阅模式是一种编程模式，消息的发送者不会发送其消息给特定的接收者，而是将发布的消息分为不同的类别直接发布，并不关注订阅者是谁。而订阅者可以对一个或多个类别感兴趣，且只接收感兴趣的消息，并且不关注是哪个发布者发布的消息。要实现这个模式，就需要一个中间代理人。   Broker，它维护着发布者和订阅者的关系，订阅者把感兴趣的主题告诉它，而发布者的信息也通过它路由到各个订阅者处。  
  
```python  
from collections import defaultdict  
route_table = defaultdict(list)  
def sub(topic, callback):  
    if callback in route_table[topic]:  
        return  
    route_table[topic].append(callback)  
  
def pub(topic, *args, **kw):  
    for func in route_table[topic]:  
        func(*args, **kw)  
  
```  
将以上代码放在 Broker.py 的模块，省去了各种参数检测、优先处理、取消订阅的需求，只向我们展示发布订阅模式的基础实现：  
  
```python
import Broker
def greeting(name):
    print('Hello, {}'.format(name))  
Broker.sub('greet', greeting)
Broker.pub('greet', 'LaiYonghao')

from state import curr, switch, stateful, State, behavior
@stateful
class People(object):
    class Workday(State):
        default = True
        @behavior   # 相当于staticmethod
        def day(self):  # 这里的self并不是Python的关键字，而是有助于我们理解状态类的宿主是People的实例
            print('work hard')
    class Weekend(State):
        @behavior
        def day(self):
            print('play harder')
people = People()
while True:
    for i in range(1, 8):
        if i == 6:
            switch(people, People.Weekend)
        if i == 1:
            switch(people, People.Workday)
        people.day()

@stateful
class User(object):
    class NeedSignin(State):
        default = True
        @behavior
        def signin(self, user, pwd):
            ...
            switch(self, Player.Signin)
    class Signin(State):
        @behavior
        def move(self, dst): ...
        @behavior
        def atk(self, other): ...

In [1]: class TestNewClass:
   ...:     __metaclass__ = type
   ...:     
In [2]: type(TestNewClass)
Out[2]: type
In [3]: TestNewClass.__bases__
Out[3]: (object,)
In [4]: a = TestNewClass()
In [5]: type(a)
Out[5]: __main__.TestNewClass
In [6]: a.__class__
Out[6]: __main__.TestNewClass

class A(object):
    def __new__(cls, *args, **kw):
        print(cls)
        print(args)
        print(kw)
        print('----------')
        instance = object.__new__(cls, *args, **kw)
        print(instance)
    def __init__(self, a, b):
        print('init gets called')
        print('self is {}'.format(self))
        self.a, self.b = a, b
a1 = A(1, 2)
print(a1.a)
print(a1.b)

# 创建一个集合能够将任何以空格隔开的字符串变为集合中的元素
class UserSet(frozenset):
    def __new__(cls, *args):
        if args and isinstance(args[0], str):
            args = (args[0].split(), ) + args[1:]
        return super(UserSet, cls).__new__(cls, *args)
# 一个工厂类根据传入的参量决定创建出哪一种产品类的实例
class Shape(object):
    def __init__(object):
        pass
    def draw(self):
        pass
class Triangle(Shape):
    def __init__(self):
        print("I am a triangle")
    def draw(self):
        print("I am drawing triangle")
class Rectangle(Shape):
    def __init__(self):
        print("I am a rectangle")
    def draw(self):
        print("I am drawing triangle")
class Trapezoid(Shape):
    def __init__(self):
        print("I am a trapezoid")
    def draw(self):
        print("I am drawing triangle")
class Diamond(Shape):
    def __init__(self):
        print("I am a diamond")
    def draw(self):
        print("I am drawing triangle")
class ShapeFactory(object):
    shapes = {'triangle': Triangle, 'rectangle': Rectangle, 'trapzoid': Trapezoid, 'diamond': Diamond}
    def __new__(cls, name):
        if name in ShapeFactory.shapes.keys():
            print('creating a new shape {}'.format(name))
            return ShapeFactory.shapes[name]()
        else:
            print('creating a new shape {}'.format(name))
            return Shape()

def foo(x):
    a = x
    def bar():
        nonlocal a
        b = a * 2
        a = b + 1
        print(a)
    return bar

class SelfTest(object):
    def __init__(self.name):
        self.name = name
    def showself(self):
        print('self here is {}'.format(self))
    def display(self):
        self.showself()
        print('The name is: {}'.format(self.name))
st = SelfTest('instance self')
st.display()
print('{}'.format(st))

self here is <__main__.SelfTest object at 0x7f440c53ba58>
The name is: instance self
<__main__.SelfTest object at 0x7f440c53ba58>

A.__dict__["m"]
A.m.__func__

In [1]: class MyClass(object):
   ...:     class_attr = 1
   ...:     
# 每一个类都有一个__dict__属性, 包含它的所有属性
In [2]: MyClass.__dict__
Out[2]:
mappingproxy({'__dict__': <attribute '__dict__' of 'MyClass' objects>,
              '__doc__': None,
              '__module__': '__main__',
              '__weakref__': <attribute '__weakref__' of 'MyClass' objects>,
              'class_attr': 1})
In [3]: my_instance = MyClass()
# 每一个实例也相应有一个实例属性, 我们通过实例访问一个属性时,
# 它首先会尝试在实例属性中查找, 找不到会到类属性中查找
In [4]: my_instance.__dict__
Out[4]: {}
# 实例访问类属性
In [5]: my_instance.class_attr
Out[5]: 1
# 如果通过实例增加一个属性,只能改变此实例的属性
In [6]: my_instance.inst_attr = 'china'
In [7]: my_instance.__dict__
Out[7]: {'inst_attr': 'china'}
# 对于类属性而言并没有丝毫变化
In [8]: MyClass.__dict__
Out[8]:
mappingproxy({'__dict__': <attribute '__dict__' of 'MyClass' objects>,
              '__doc__': None,
              '__module__': '__main__',
              '__weakref__': <attribute '__weakref__' of 'MyClass' objects>,
              'class_attr': 1})
# 我们可以动态地给类增加一个属性
In [9]: MyClass.class_attr2 = 100
In [10]: my_instance.class_attr2
Out[10]: 100
# 但Python的内置类型并不能随意地为它增加属性或方法

In [1]: class MyClass(object):
   ...:     def my_method(self):
   ...:         print('my_method')
   ...:         
In [2]: MyClass.__dict__['my_method']
Out[2]: <function __main__.MyClass.my_method>
In [3]: MyClass.my_method
Out[3]: <function __main__.MyClass.my_method>
In [4]: type(MyClass.my_method)
Out[4]: function
In [5]: type(MyClass.__dict__['my_method'])
Out[5]: function

>>> with open('test.txt', 'w') as f:
...     f.write('test')
... 
4
>>> f.__enter__
<built-in method __enter__ of _io.TextIOWrapper object at 0x7f1b967aaa68>
>>> f.__exit__
<built-in method __exit__ of _io.TextIOWrapper object at 0x7f1b967aaa68>