• • 前言
  • 演示
    • 案例一
    • 案例二
  • 總結

前言

然後現在用的是Python了，所以需要迭代一下。網上搜索了下，相關的還真不少，還有pylucene，但是相比較而言，whoosh更為出色。那今天就用它吧。

安裝它也比較簡單。

pip install whoosh

這樣就可以了。

目標： 對自己的部落格進行“站內搜尋”，來稍微改善一下CSDN站內查詢的缺點。

模組化

最近越來越喜歡把任務模組化了，這樣單個的功能也比較容易管理，而且整合的時候對整合測試也比較方便。或者新增新功能，重構，都很方便。

針對上面的需求，我這裡設計了幾個小模組，待會逐個進行解釋。

登入模組

登入模組是有點必須的，這是因為在獲取部落格詳細內容的時候，需要有一個已經登入的session會話來支撐，否則拿不到資料。

先前也寫過一點關於CSDN模擬登陸的例子，當時完成的功能有

• 模擬登陸
• 頂、踩文章
• 發評論
• 獲取博主詳情

為了不讓別有用心的人拿程式碼做壞事，我這裡就不貼程式碼了。技術方面歡迎私信，或者在文章下面發評論。

下面把模擬登陸的程式碼補上。

class Login(object):
    """
    Get the same session for blog's backing up. Need the special username and password of your account.
    """
 


    def __init__(self):
        # the common headers for this login operation.
        self.headers = {
            'Host': 'passport.csdn.net',
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.110 Safari/537.36',
        }

    def
 
 login(self, username, password):
        if username and password:
            self.username = username
            self.password = password
        else:
            raise Exception('Need Your username and password!')

        loginurl = 'https://passport.csdn.net/account/login'
        # get the 'token' for webflow
        self.session = requests.Session()
        response = self.session.get(url=loginurl, headers=self.headers)
        soup = BeautifulSoup(response.text, 'html.parser')
        # Assemble the data for posting operation used in logining.
        self.token = soup.find('input', {'name': 'lt'})['value']

        payload = {
            'username': self.username,
            'password': self.password,
            'lt': self.token,
            'execution': soup.find('input', {'name': 'execution'})['value'],
            '_eventId': 'submit'
        }
        response = self.session.post(url=loginurl, data=payload, headers=self.headers)

        # get the session
        return self.session if response.status_code == 200 else None

部落格掃描模組

部落格掃描這個模組不需要登入狀態的支援，完成的功能是掃描博主的文章總數，以及每個文章對應的URL連結。因為接下來會用它來獲取文章的詳情。

class BlogScanner(object):
    """
    Scan for all blogs
    """

    def __init__(self, domain):
        self.username = domain
        self.rooturl = 'http://blog.csdn.net'
        self.bloglinks = []
        self.headers = {
            'Host': 'blog.csdn.net',
            'Upgrade - Insecure - Requests': '1',
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.110 Safari/537.36',
        }

    def scan(self):
        # get the page count
        response = requests.get(url=self.rooturl + "/" + self.username, headers=self.headers)
        soup = BeautifulSoup(response.text, 'html.parser')

        pagecontainer = soup.find('div', {'class': 'pagelist'})
        pages = re.findall(re.compile('(\d+)'), pagecontainer.find('span').get_text())[-1]

        # construnct the blog list. Likes: http://blog.csdn.net/Marksinoberg/article/list/2
        for index in range(1, int(pages) + 1):
            # get the blog link of each list page
            listurl = 'http://blog.csdn.net/{}/article/list/{}'.format(self.username, str(index))
            response = requests.get(url=listurl, headers=self.headers)
            soup = BeautifulSoup(response.text, 'html.parser')
            try:
                alinks = soup.find_all('span', {'class': 'link_title'})
                # print(alinks)
                for alink in alinks:
                    link = alink.find('a').attrs['href']
                    link = self.rooturl + link
                    self.bloglinks.append(link)
            except Exception as e:
                print('出現了點意外！\n' + e)
                continue

        return self.bloglinks

部落格詳情模組

關於部落格詳情，我倒是覺得CSDN做的真不賴。而且是json格式的。話不多說，看下登入狀態下能獲取到的部落格的詳細內容吧。

這下思路很清晰了，就是要獲取標題，URL，標籤，摘要描述， 文章正文內容。程式碼如下：

class BlogDetails(object):
    """
    Get the special url for getting markdown file.
    'url':部落格URL
    'title': 部落格標題
    'tags': 部落格附屬標籤
    'description': 部落格摘要描述資訊
    'content': 部落格Markdown原始碼
    """

    def __init__(self, session, blogurl):
        self.headers = {
            'Referer': 'http://write.blog.csdn.net/mdeditor',
            'Host': 'passport.csdn.net',
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.110 Safari/537.36',
        }
        # constructor the url: get article id and the username
        # http://blog.csdn.net/marksinoberg/article/details/70432419
        username, id = blogurl.split('/')[3], blogurl.split('/')[-1]
        self.blogurl = 'http://write.blog.csdn.net/mdeditor/getArticle?id={}&username={}'.format(id, username)
        self.session = session

    def getSource(self):
        # get title and content for the assigned url.
        try:
            tempheaders = self.headers
            tempheaders['Referer'] = 'http://write.blog.csdn.net/mdeditor'
            tempheaders['Host'] = 'write.blog.csdn.net'
            tempheaders['X-Requested-With'] = 'XMLHttpRequest'
            response = self.session.get(url=self.blogurl, headers=tempheaders)
            soup = json.loads(response.text)
            return {
                'url': soup['data']['url'],
                'title': soup['data']['title'],
                'tags': soup['data']['tags'],
                'description': soup['data']['description'],
                'content': soup['data']['markdowncontent'],
            }
        except Exception as e:
            print("介面請求失敗! 詳細資訊為：{}".format(e))

搜尋模組

搜尋模組是今天的核心，使用到的庫就是whoosh， 真的是很貼心的一個庫，而且文件詳細，簡單易懂。我這蹩腳的英文水平都可以，你也一定可以的。

預設的文字分析器是英文的，所以為了更好的照顧到中文相關，就得處理一下中文分詞，於是在網上抄了一個，不過效果不咋地。

class ChineseTokenizer(Tokenizer):
    def __call__(self, value, positions=False, chars=False, keeporiginal=False,
                 removestops=True, start_pos=0, start_char=0, mode='', **kwargs):
        assert isinstance(value, text_type), "%r is not unicode"%value
        t = Token(positions=positions, chars=chars, removestops=removestops, mode=mode, **kwargs)
        # 使用jieba分詞，分解中文
        seglist = jieba.cut(value, cut_all=False)
        for w in seglist:
            t.original = t.text = w
            t.boost = 1.0
            if positions:
                t.pos = start_pos + value.find(w)
            if chars:
                t.startchar = start_char + value.find(w)
                t.endchar = start_pos + value.find(w) + len(w)
            yield t

def ChineseAnalyzer():
    return ChineseTokenizer()


class Searcher(object):
    """
    Firstly： define a schema suitable for this system. It may should be hard-coded.
            'url':部落格URL
            'title': 部落格標題
            'tags': 部落格附屬標籤
            'description': 部落格摘要描述資訊
            'content': 部落格Markdown原始碼
    Secondly: add documents(blogs)
    Thridly: search user's query string and return suitable high score blog's paths.
    """
    def __init__(self):
        # define a suitable schema
        self.schema = Schema(url=ID(stored=True),
                             title=TEXT(stored=True),
                             tags=KEYWORD(commas=True),
                             description=TEXT(stored=True),
                             content=TEXT(analyzer=ChineseAnalyzer()))
        # initial a directory to storage indexes info
        if not os.path.exists("indexdir"):
            os.mkdir("indexdir")
        self.indexdir = "indexdir"
        self.indexer = create_in(self.indexdir, schema=self.schema)


    def addblog(self, blog):
        writer = self.indexer.writer()
        # write the blog details into indexes
        writer.add_document(url=blog['url'],
                            title=blog['title'],
                            tags=blog['tags'],
                            description=blog['description'],
                            content=blog['content'])
        writer.commit()

    def search(self, querystring):
        # make sure the query string is unicode string.
        # querystring = u'{}'.format(querystring)
        with self.indexer.searcher() as seracher:
            query = QueryParser('content', self.schema).parse(querystring)
            results = seracher.search(query)
            # for item in results:
            #    print(item)
        return results

演示

好了，差不多就是這樣了。下面來看下執行的效果。

案例一

首先看下對於DBHelper這個關鍵字的搜尋， 因為文章過多的話計算也是比較慢的，所以就爬取前幾篇文章好了。

# coding: utf8

# @Author: 郭 璞
# @File: TestAll.py                                                                 
# @Time: 2017/5/12                                   
# @Contact: 1064319632@qq.com
# @blog: http://blog.csdn.net/marksinoberg
# @Description: 
from whooshlearn.csdn import Login, BlogScanner, BlogDetails, Searcher

login = Login()
session = login.login(username="Username", password="password")
print(session)

scanner = BlogScanner(domain="Marksinoberg")
blogs = scanner.scan()
print(blogs[0:3])

blogdetails = BlogDetails(session=session, blogurl=blogs[0])
blog = blogdetails.getSource()
print(blog['url'])
print(blog['description'])
print(blog['tags'])

# test whoosh for searcher
searcher = Searcher()
counter=1
for item in blogs[0:7]:
    print("開始處理第{}篇文章".format(counter))
    counter+=1
    details = BlogDetails(session=session, blogurl=item).getSource()
    searcher.addblog(details)
# searcher.addblog(blog)
searcher.search('DbHelper')
# searcher.search('Python')

程式碼執行結果如下：

不難發現，本人部落格只有前兩篇是關於DBHelper 的文章，所以命中了這兩個document。看起來還不錯。

案例二

下面再來試試其他的關鍵字。比如Python。

# coding: utf8

# @Author: 郭 璞
# @File: TestAll.py                                                                 
# @Time: 2017/5/12                                   
# @Contact: 1064319632@qq.com
# @blog: http://blog.csdn.net/marksinoberg
# @Description: 
from whooshlearn.csdn import Login, BlogScanner, BlogDetails, Searcher

login = Login()
session = login.login(username="username", password="password")
print(session)

scanner = BlogScanner(domain="Marksinoberg")
blogs = scanner.scan()
print(blogs[0:3])

blogdetails = BlogDetails(session=session, blogurl=blogs[0])
blog = blogdetails.getSource()
print(blog['url'])
print(blog['description'])
print(blog['tags'])

# test whoosh for searcher
searcher = Searcher()
counter=1
for item in blogs[0:10]:
    print("開始處理第{}篇文章".format(counter))
    counter+=1
    details = BlogDetails(session=session, blogurl=item).getSource()
    searcher.addblog(details)
# searcher.addblog(blog)
# searcher.search('DbHelper')
searcher.search('Python')

然後依然來看下執行的效果。

命中了4條記錄，命中率也還算說得過去。

總結

最後來總結下。關於whoosh站內搜尋的問題， 要向更高精度的匹配到文字結果，其實還需要很多地方優化。QueryParser 這塊其實還有很多需要挖掘。

另外高亮顯示查詢結果也是很方便的。官方文件上有詳細的介紹。

最後一步就是中文問題，目前我還沒有什麼好的辦法來提高分詞和命中率。