f = open('.\\tang300.xml','r',encoding='UTF-8')
for line in f.readlines()[0:10]:
    print(line)
f.close()

import xml.dom.minidom
import xml.sax
from collections import OrderedDict
import re
'''
使用minidom解析器打开 XML 文档，当然使用sax也行。或者也可以尝试自己写解析算法，比如正则表达式。
不同的方法实现得好都有机会被作为作业样本并获得加分
'''

DOMTree = xml.dom.minidom.parse("tang300.xml")
collection = DOMTree.documentElement
# print(collection)

# 在集合中获取所有诗句
poems = collection.getElementsByTagName("作业用唐诗")

poemIDdict = {}
poemSavedDict = {}
authorSavedList = []


strinfo = re.compile(r'[#&$%％]')

for poem in poems:
    # ID = poem.getElementsByTagName('ID')[0].childNodes[0].data
    Poem_id = int(poem.getElementsByTagName('Poem_id')[0].childNodes[0].data)
    line_number = int(poem.getElementsByTagName('line_number')[0].childNodes[0].data)
    contance_tmp = poem.getElementsByTagName('contance')[0].childNodes[0].data
    contance = strinfo.sub('', contance_tmp)

    if Poem_id not in poemIDdict:
        poemIDdict[Poem_id] = {line_number: contance}
    else:
        poemIDdict[Poem_id][line_number] = contance

#print(poemIDdict[4371])

def saved_poem(name,num):
    count = 0
    poemlist = []
    authorSavedList.append(name)

    for i in poemIDdict.values():
        poemtmpList = []
        i = OrderedDict(sorted(i.items(),key = lambda t:t[0]))

        if i[-1] == name:
            count += 1
            for v in i.values():
                poemtmpList.append(v)
            poemlist.append(tuple(poemtmpList))

        if count == num:
            break

    if len(poemlist) < num:
        print('#####诗人{}的诗不足{}首#####'.format(name,num))

    if name not in poemSavedDict:
        poemSavedDict[name] = poemlist
    else:
        poemSavedDict[name] += poemlist

    return poemlist

lb = saved_poem('李白',20)
df = saved_poem('杜甫',20)
bjy = saved_poem('白居易',20)
ww = saved_poem('王維',20)

print(lb)

def search_poem(author,num = 20,printtitle = True):
    if author not in poemSavedDict:
        print("未储存该诗人的诗")
        return [None]
    else:
        title_list = []
        savedpoems = poemSavedDict[author]

        for poem in savedpoems:
            title_list.append(poem[0])

        if printtitle:
            print(title_list)

    return title_list

search_poem("李白")

import random

class BasePublisher(object):
    def __init__(self,name):
        self.readers = []
        self.publishername = name

    def subscribeReader(self, reader):
        if reader not in self.readers:
            self.readers.append(reader)
        else:
            print("{}已订阅过。".format(reader))

    def unsubscribeReader(self, reader):
        try:
            self.readers.remove(reader)
        except:
            print("{}尚未订阅，无法取消订阅。".format(reader))

    def notifyReader(self,msggenerator):
        raise NotImplementedError

    def __str__(self):
        raise NotImplementedError

class Publisher(BasePublisher):

    #Poemtank = lb+ww+bjy+df
    Poemtank = []

    for pl in poemSavedDict.values():
        Poemtank += pl

    def __init__(self,name):
        BasePublisher.__init__(self,name)
        self.poemcount = {}

    def __str__(self):
        rdlist = []
        totalpoemcount = 0
        for r in self.readers:
            rdlist.append(r.getname())
        for p in self.poemcount.values():
            totalpoemcount += p

        return "{}的订阅人名单：{}，合计更新{}首诗,其中{}".format(self.publishername,rdlist,totalpoemcount,self.poemcount)

    def get_new_poem(self):
        try:
            p = self.Poemtank[random.randint(0,len(self.Poemtank)-1)]
            self.Poemtank.remove(p)
            for aut in authorSavedList:
                if aut in p:
                    if aut not in self.poemcount:
                        self.poemcount[aut] = 1
                    else:
                        self.poemcount[aut] += 1
                    return p,aut
            raise Exception

        except:
            print("Publisher没有新诗了")
            return None,None


    def notifyReader(self,poemgetter):
        poem,author = poemgetter
        for reader in self.readers:
            reader.receivePoem(self.publishername,poem,author)

import threading

class BaseReader(object):

    def subscribeToPublisher(self, publisher):
        publisher.subscribeReader(self)

    def unsubscribeToPublisher(self, publisher):
        publisher.unsubscribeReader(self)

    def __str__(self):
        raise NotImplementedError

    def receivePoem(self, publisher, poem , author):
        print('thread id :{}'.format(threading.current_thread().name)) #如果3.2你使用多线程的话请保留此句，
        #如果使用多进程的话请类似地输出进程id
        raise NotImplementedError

    def printStatistics(self):
        # 打印消息
        raise NotImplementedError

    def getname(self):
        raise NotImplementedError

class ReaderType1(BaseReader):

    def __init__(self, _name):
        BaseReader.__init__(self)
        self.poemset = {}
        self.readername = _name
        self.newestpoem = None

    def __str__(self):
        try:
            for v in self.poemset.values():
                for p in v:
                    print("#####{}#####".format(self.readername))
                    for l in p:
                        print(l)
                    print(" ")
        except:
            print("{}没有收到新诗".format(self.readername))
        finally:
            return '##### END #####'


    def receivePoem(self, publisher, poem, author):
        print('thread id :{}'.format(threading.current_thread().name))
        if poem == None:
            print("Reader没有收到新诗")
        else:
            self.newestpoem = poem
            if author in self.poemset:
                self.poemset[author].append(poem)
            else:
                self.poemset[author] = [poem]

            print("{}成功从{}处收取一首诗".format(self.readername,publisher))

    def printStatistics(self):
        try:
            for v in self.poemset.values():
                for p in v:
                    print("#####{}#####".format(self.readername))
                    for l in p:
                        print(l)
                    print(" ")
        except:
            print("{}没有收到新诗".format(self.readername))

    def getname(self):
        return self.readername

# 第二种读者
class ReaderType2(BaseReader):

    def __init__(self, _name):
        BaseReader.__init__(self)
        self.readername = _name
        self.newestpoem = None

    def __str__(self):
        try:
            print("#####{}#####".format(self.readername))
            for l in self.newestpoem:
                print(l)
            print(" ")
        except:
            print("{}没有收到新诗".format(self.readername))
        finally:
            return '##### END #####'


    def receivePoem(self, publisher, poem , author):
        print('thread id :{}'.format(threading.current_thread().name))
        if poem == None:
            print("{}没有收到新诗".format(self.readername))
            print(' ')
        else:
            self.newestpoem = poem
            print("{}成功从{}处收取一首诗".format(self.readername,publisher))

    def printStatistics(self):
        try:
            print("#####{}#####".format(self.readername))
            for l in self.newestpoem:
                print(l)
            print(" ")
        except:
            print("{}没有收到新诗".format(self.readername))

    def getname(self):
        return self.readername

Publisher = Publisher("Publisher")
Alice=ReaderType1('Alice')
Bob=ReaderType2('Bob')
Carol=ReaderType2('Carol')

Alice.subscribeToPublisher(Publisher)
Bob.subscribeToPublisher(Publisher)
## 请在这里利用Publisher任意发出几首诗来测试你的代码
Publisher.notifyReader(Publisher.get_new_poem())
Publisher.notifyReader(Publisher.get_new_poem())
Publisher.notifyReader(Publisher.get_new_poem())
Publisher.notifyReader(Publisher.get_new_poem())
Publisher.notifyReader(Publisher.get_new_poem())

Alice.printStatistics()
Bob.printStatistics()
Carol.printStatistics()
print(Publisher)

Carol.subscribeToPublisher(Publisher)
Bob.unsubscribeToPublisher(Publisher)
##再任意发出几首诗进行测试
Publisher.notifyReader(Publisher.get_new_poem())
Publisher.notifyReader(Publisher.get_new_poem())
Publisher.notifyReader(Publisher.get_new_poem())
Publisher.notifyReader(Publisher.get_new_poem())
Publisher.notifyReader(Publisher.get_new_poem())

Alice.printStatistics()
Bob.printStatistics()
Carol.printStatistics()
print(Publisher)

class MultiThreadPublisher(BasePublisher):

    #Poemtank = lb+ww+bjy+df
    Poemtank = []

    for pl in poemSavedDict.values():
        Poemtank += pl

    def __init__(self,name):
        BasePublisher.__init__(self,name)
        self.poemcount = {}

    def __str__(self):
        rdlist = []
        totalpoemcount = 0
        for r in self.readers:
            rdlist.append(r.getname())
        for p in self.poemcount.values():
            totalpoemcount += p

        return "{}的订阅人名单：{}，合计更新{}首诗,其中{}".format(self.publishername,rdlist,totalpoemcount,self.poemcount)

    def get_new_poem(self):
        try:
            p = self.Poemtank[random.randint(0,len(self.Poemtank)-1)]
            self.Poemtank.remove(p)
            for aut in authorSavedList:
                if aut in p:
                    if aut not in self.poemcount:
                        self.poemcount[aut] = 1
                    else:
                        self.poemcount[aut] += 1
                    return p,aut
            raise Exception

        except:
            print("Publisher没有新诗了")
            return None,None


    def notifyReader(self,poemgetter):
        poem,author = poemgetter
        for reader in self.readers:
            reader.receivePoem(self.publishername,poem,author)

    def startMultiTreadNotifier(self,MT = 5):
        for _ in range(MT):
            t = threading.Thread(target=self.notifyReader,args = (self.get_new_poem(),))
            t.start()
            t.join()

MultiThreadPublisher = MultiThreadPublisher("MultiPublisher")
Alice.subscribeToPublisher(MultiThreadPublisher)
Bob.subscribeToPublisher(MultiThreadPublisher)
Carol.subscribeToPublisher(MultiThreadPublisher)
print(Alice)

##请发出几首诗测试
# MT = X:发出X首诗
MultiThreadPublisher.startMultiTreadNotifier(MT = 5)

Alice.printStatistics()
Bob.printStatistics()
Carol.printStatistics()
print(MultiThreadPublisher)