Python之由公司名推算出公司官网(余弦相似度)

读大学时期写的博文

1.问题

对展会数据分类后，我的新任务是如何通过 公司名、公司地址、国家等海关数据推断出该公司的官网网站（若官网不存在则不考虑） 以下数据仅供参考：

需要得到结果：

2.解决

由数据可看出，公司名是绝对存在的，故解决思路是从公司名出发，而不怎么全面的国家以及地址信息则用来提高准确度。

大体思路是这样的，若公司官网存在，那么通过搜索引擎定会被检索到，搜索引擎自然首选 google，所以可以先通过获取谷歌搜索的结果，然后分析获取的结果，从而得出最可能是该公司网站的 url。 初步搜索一下，看看各种情况：

• 第一种情况，检索即可很直观地得出结果

• 第二种情况，检索不能直观地得出结果，但官网确实存在（第二检索个结果）

• 第三种情况，输入公司名+公司地址和只输入公司名得出的结果不一样

对于第三种情况，可以看出输入公司名+公司地址得出的结果是绝对正确的。

观察第三种情况，当输入公司名+公司地址时，返回结果的右侧会出现公司的详细信息，经过验证，若出现这种情况，则其 website对应的 url绝对正确。

故代码的第一步骤可以首先检索公司名+公司地址，观察 website元素是否存在，若存在，返回公司官网，否则，对公司名进行检索，代码如下：

1. def searchWeb(query, tld='com', lang='en', tbs='0', num=10, safe='off', tpe='', user_agent=None):

2.    query = quote_plus(query)

3.    get_page(url_home % vars())

4.    url = url_search_num % vars()

5.    # Request the Google Search results page.

6.    html = get_page(url)

7.    try:

8.        href = re.findall(r'Directions</a><a\s*class="fl"\s*href="(.*?)".*?>Website', str(html))[0]

9.        link = filter_result(href)

10.        return link

11.    except:

12.        pass

13.    return None

能直接获取公司官网毕竟是少数，大多数据还是要通过一步步计算得出，主要经过以下步骤：

• 获取搜索引擎检索结果提取url

• 初步排除某些url

• 余弦相似度计算最可能的结果

2.1.获取搜索引擎检索结果提取url

对于谷歌搜索，我使用了 MarioVilas的项目google，毕竟在国内，为了以防万一我也写了 yahoo搜索，代码如下：

1. #!/usr/bin/env

2. # -*-coding:utf-8-*-

3. # script: yahooSearch.py

4. __author__ = 'howie'

5. 
   

6. import sys

7. import time

8. 
   

9. if sys.version_info[0] > 2:

10.    from urllib.request import Request, urlopen

11.    from urllib.parse import quote_plus, urlparse

12. else:

13.    from urllib import quote_plus

14.    from urllib2 import Request, urlopen

15.    from urlparse import urlparse, parse_qs

16. 
    

17. try:

18.    from bs4 import BeautifulSoup

19. 
    

20.    is_bs4 = True

21. except ImportError:

22.    from BeautifulSoup import BeautifulSoup

23. 
    

24.    is_bs4 = False

25. 
    

26. url_search = "https://search.yahoo.com/search?p=%(query)s&b=%(start)s&pz=%(num)s"

27. 
    

28. headers = {

29.    'accept-encoding': 'gzip, deflate, sdch, br',

30.    'accept-language': 'zh-CN,zh;q=0.8,en-US;q=0.6,en;q=0.4',

31.    'upgrade-insecure-requests': '1',

32.    'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',

33.    'cache-control': 'max-age=0',

34.    'authority': ' search.yahoo.com'

35. }

36. # 默认user_agent

37. user_agent = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36'

38. 
    

39. 
    

40. def filter_link(link):

41.    try:

42.        linkData = urlparse(link)

43.        if linkData.netloc and "yahoo.com" not in linkData.netloc and "/search/srpcache" not in linkData.path:

44.            return link

45.    except Exception:

46.        pass

47.    return None

48. 
    

49. 
    

50. def yahooSearch(query, start=0, num=10, page=1, pause=1.0):

51.    """

52.    获取雅虎搜索url

53.    :param query: 搜索关键词

54.    :param start: 开始条目,最好为0

55.    :param num: 搜索条目 建议10的倍数

56.    :param page: 页数

57.    :param pause: 停顿时间

58.    :return: 返回url

59.    """

60.    query = quote_plus(query)

61.    while page > 0:

62.        url = url_search % vars()

63.        time.sleep(pause)

64.        request = Request(url)

65.        request.add_header('User-Agent', user_agent)

66.        response = urlopen(request)

67.        html = response.read()

68.        if is_bs4:

69.            soup = BeautifulSoup(html, 'html.parser')

70.        else:

71.            soup = BeautifulSoup(html)

72.        anchors = soup.find(id="web").find_all('a')

73.        for a in anchors:

74.            try:

75.                link = filter_link(a["href"])

76.                if link:

77.                    yield link

78.            except KeyError:

79.                continue

80.        start += num + 1

81.        page -= 1

82. 
    

83. 
    

84. if __name__ == '__main__':

85.    # GOLD INC 18245 E 40TH AVE AURORA CO 80011 US

86.    for url in yahooSearch("GOLD INC 18245 E 40TH AVE AURORA CO 80011 US"):

87.        print(url)

2.2.初步排除某些url

这个可根据个人需求来配置，可添加 webConfig.py脚本，排除某些 url:

1. # -*-coding:utf-8-*-

2. __author__ = 'howie'

3. 
   

4. config = dict(

5.    # www开头或分割后数组大于二的网站

6.    forbid_www=["www.linkedin.com", "www.alibaba.com"],

7.    # 非www开头的网站

8.    forbid=["imexbb.com", "made-in-china.com"]

9. )

以公司名 BENKAICo.,Ltd为例，初步获取url： ['http://www.benkaico.com','http://hisupplier.com','http://www.hktdc.com/en']

2.3.余弦相似度计算最可能的结果

对于公司 BENKAICo.,Ltd，我们获得了三个结果，现在又该如何从该列表中取得最可能的结果呢。

这里可以采用余弦相似度，具体公式可google，稍稍解释下，对于这三个网站：

1. ['http://www.benkaico.com', 'http://hisupplier.com', 'http://www.hktdc.com/en']```

2. 可以通过计算各个网站的`title`和`BENKAI Co.,Ltd`的相似程度来取得最可能的结果。

3. #####2.3.1：对各网站title进行分词

4. ```python

5. {'http://www.benkaico.com': ['benkai', 'co.', ',', 'ltd', '.'],

6. 'http://www.hktdc.com/en': ['hktdc.com', 'â\x80\x93', 'page', 'not', 'found'],

7. 'http://hisupplier.com': ['china', 'suppliers', ',', 'suppliers', 'directory', ',', 'china', 'manufacturers', 'directory', '-', 'hisupplier.com']}

2.3.2：构建单词向量

1. {'http://www.benkaico.com': [[0, 1, 1, 1, 1], [1, 1, 1, 1, 1]],

2. 'http://www.hktdc.com/en': [[1, 1, 0, 0, 1, 0, 0, 0, 1], [0, 0, 1, 1, 0, 1, 1, 1, 0]],

3. 'http://hisupplier.com': [[0, 0, 0, 1, 0, 0, 1, 1, 0, 1], [2, 1, 1, 0, 2, 1, 2, 0, 2, 0]]}

2.3.3:计算余弦相似度

1. {'http://www.benkaico.com': 0.94427190999915878,

2. 'http://www.hktdc.com/en': 0.0,

3. 'http://hisupplier.com': 0.31451985913875646}

通过比较，可以看到 http://www.benkaico.com相似度最高的结果，跟真实结果一样。

全部步骤代码如下：

1. # -*-coding:utf-8-*-

2. __author__ = 'howie'

3. from urllib import parse

4. from bs4 import BeautifulSoup

5. from collections import defaultdict

6. import requests

7. import re

8. import nltk

9. import time

10. from config.webConfig import config

11. from CosineSimilarity import CosineSimilarity

12. from search.yahooSearch import yahooSearch

13. from search.gooSearch import search, searchWeb

14. 
    

15. 
    

16. class Website(object):

17.    """

18.    通过公司名等信息获取网站官网

19.    """

20. 
    

21.    def __init__(self, engine='google'):

22.        self.forbid_www = config["forbid_www"]

23.        self.forbid = config["forbid"]

24.        self.engine = engine

25. 
    

26.    def get_web(self, query, address=""):

27.        """

28.        获取域名

29.        :param query: 搜索词

30.        :param address: 在此加上地址时，query最好是公司名

31.        :return: 返回最可能是官网的网站

32.        """

33.        if self.engine == 'google' and address:

34.            allQuery = query + " " + address

35.            result = searchWeb(query=allQuery, num=5)

36.            if result:

37.                return result

38.        allDomain = self.get_domain(query)

39.        if len(allDomain) == "1":

40.            website = allDomain[0]

41.        else:

42.            # 初步判断网站域名

43.            counts = self.get_counts(allDomain)

44.            largest = max(zip(counts.values(), counts.keys()))

45.            if largest[0] > len(allDomain) / 2:

46.                website = largest[1]

47.            else:

48.                # 获取对应域名标题

49.                domainData = self.get_title(set(allDomain))

50.                # 计算相似度

51.                initQuery = nltk.word_tokenize(query.lower(), language='english')

52.                # 余弦相似性计算相似度

53.                cos = CosineSimilarity(initQuery, domainData)

54.                wordVector = cos.create_vector()

55.                resultDic = cos.calculate(wordVector)

56.                website = cos.get_website(resultDic)

57.        return website

58. 
    

59.    def get_domain(self, query):

60.        """

61.         获取谷歌搜索后的域名

62.        :param query:搜索条件

63.        :return:域名列表

64.        """

65.        allDomain = []

66.        if self.engine == "google":

67.            for url in search(query, num=5, stop=1):

68.                allDomain += self.parse_url(url)

69.        elif self.engine == "yahoo":

70.            for url in yahooSearch(query):

71.                allDomain += self.parse_url(url)

72.        if not allDomain:

73.            allDomain.append('')

74.        return allDomain

75. 
    

76.    def parse_url(self, url):

77.        allDomain = []

78.        domainParse = parse.urlparse(url)

79.        # 英文网站获取

80.        if "en" in domainParse[2].lower().split('/'):

81.            domain = domainParse[1] + "/en"

82.        else:

83.            domain = domainParse[1]

84.        domainList = domain.split('.')

85.        # 排除干扰网站

86.        if len(domainList) >= 3 and domainList[0] != "www":

87.            isUrl = ".".join(domain.split('.')[-2:])

88.            if isUrl not in self.forbid:

89.                allDomain.append(domainParse[0] + "://" + isUrl)

90.        elif domain not in self.forbid_www:

91.            allDomain.append(domainParse[0] + "://" + domain)

92.        return allDomain

93. 
    

94.    def get_title(self, setDomain):

95.        """

96.        获取对应网站title，并进行分词

97.        :param allDomain: 网站集合

98.        :return: 网站:title分词结果

99.        """

100.        domainData = {}

101.        for domain in setDomain:

102.            headers = {

103.                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",

104.                "Accept-Encoding": "gzip, deflate, sdch",

105.                "Accept-Language": "zh-CN,zh;q=0.8,en-US;q=0.6,en;q=0.4",

106.                "Cache-Control": "max-age=0",

107.                "Proxy-Connection": "keep-alive",

108.                "Upgrade-Insecure-Requests": "1",

109.                "User-Agent": "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.89 Safari/537.36",

110.            }

111.            try:

112.                data = requests.get(domain, headers=headers).text

113.                soup = BeautifulSoup(data, 'html.parser')

114.                title = soup.title.get_text()

115.                title = re.sub(r'\r\n', '', title.strip())

116.                titleToken = nltk.word_tokenize(title.lower(), language='english')

117.                domainData[domain] = titleToken

118.            except:

119.                pass

120.        return domainData

121. 
     

122.    def get_counts(self, allDomain):

123.        """

124.        返回网站列表各个域名数量

125.        :param allDomain: 网站列表

126.        :return: 网站:数量

127.        """

128.        counts = defaultdict(int)

129.        for eachDomain in allDomain:

130.            counts[eachDomain] += 1

131.        return counts

132. 
     

133. 
     

134. if __name__ == '__main__':

135.    # allQuery = ["National Sales Company, Inc.", "Decor Music Inc.","Fujian Xishi Co., Ltd","Kiho USA Inc.","BusinessPartner Co.,ltd","BENKAI Co.,Ltd"]

136.    # GOLD INC 18245 E 40TH AVE AURORA CO 80011 US

137.    allQuery = ["ALZARKI INTERNATIONAL"]

138.    website = Website(engine='google')

139.    for query in allQuery:

140.        time.sleep(2)

141.        website = website.get_web(query=query)

142.        print(website)

计算余弦相似度代码

1. # -*-coding:utf-8-*-

2. # script: CosineSimilarity.py

3. __author__ = 'howie'

4. import numpy as np

5. from functools import reduce

6. from math import sqrt

7. 
   

8. 
   

9. class CosineSimilarity(object):

10.    """

11.    余弦相似性计算相似度

12.    """

13. 
    

14.    def __init__(self, initQuery, domainData):

15.        self.title = initQuery

16.        self.data = domainData

17. 
    

18.    def create_vector(self):

19.        """

20.        创建单词向量

21.        :return: wordVector = {} 目标标题以及各个网站标题对应的单词向量

22.        """

23.        wordVector = {}

24.        for web, value in self.data.items():

25.            wordVector[web] = []

26.            titleVector, valueVector = [], []

27.            allWord = set(self.title + value)

28.            for eachWord in allWord:

29.                titleNum = self.title.count(eachWord)

30.                valueNum = value.count(eachWord)

31.                titleVector.append(titleNum)

32.                valueVector.append(valueNum)

33.            wordVector[web].append(titleVector)

34.            wordVector[web].append(valueVector)

35.        return wordVector

36. 
    

37.    def calculate(self, wordVector):

38.        """

39.        计算余弦相似度

40.        :param wordVector: wordVector = {} 目标标题以及各个网站标题对应的单词向量

41.        :return: 返回各个网站相似度值

42.        """

43.        resultDic = {}

44.        for web, value in wordVector.items():

45.            valueArr = np.array(value)

46.            # 余弦相似性

47.            squares = []

48.            numerator = reduce(lambda x, y: x + y, valueArr[0] * valueArr[1])

49.            square_title, square_data = 0.0, 0.0

50.            for num in range(len(valueArr[0])):

51.                square_title += pow(valueArr[0][num], 2)

52.                square_data += pow(valueArr[1][num], 2)

53.            squares.append(sqrt(square_title))

54.            squares.append(sqrt(square_data))

55.            mul_of_squares = reduce(lambda x, y: x * y, squares)

56.            resultDic[web] = numerator / sum_of_squares

57.        return resultDic

58. 
    

59.    def get_website(self, resultDic):

60.        """

61.        获取最可能是官网的网站

62.        :param resultDic: 各个网站相似度值

63.        :return: 最可能的网站 也可能为空

64.        """

65.        website = ''

66.        largest = max(zip(resultDic.values(), resultDic.keys()))

67.        if largest[0]:

68.            website = largest[1]

69.        # 当相似度为0

70.        else:

71.            websites = [key for key, values in resultDic.items() if values == 0.0]

72.            for eachWebsite in websites:

73.                keyword = ','.join(self.data[eachWebsite]).lower()

74.                if 'home' in keyword or "welcome" in keyword:

75.                    website = eachWebsite

76.        return website

3.总结

至此，若有更好的解决方案，欢迎赐教，谢谢。

往期推荐：

如何用PEP 8编写优雅的Python代码

Sanic中文教程合集：免费下载

如何用Python创建一个简单的神经网络

Python之装饰器