【Python | 邊學邊敲邊記】第三次：URL去重策略

一、前言

今天給大家分享的是，Python爬蟲裡url去重策略及實現。

二、url去重及策略簡介

1.url去重

    從字面上理解，url去重即去除重複的url,在爬蟲中就是去除已經爬取過的url,避免重複爬取，既影響爬蟲效率，又產生冗餘資料。

2.url去重策略

    從表面上看，url去重策略就是消除url重複的方法，常見的url去重策略有五種，如下：

1


# 1.將訪問過的ur儲存到資料庫中




2


# 2.將訪問過的ur儲存到set(集合)中,只需要o(1)的代價就可以查詢url




3


#       10000000*2byte*50個字元/1024/1024/1024=9G




4


# 3.url經過md5等方法雜湊後儲存到set中




5


# 4.用 bitmap方法,將訪問過的ur透過hash函式對映到某一位




6


# 5. bloomfilter方法對 bitmap進行改進,多重hash函式降低衝突

三、看程式碼，邊學邊敲邊記url去重策略

1.將訪問過的ur儲存到資料庫中（初學使用）

實現起來最簡單，但效率最低。
其核心思想是，把頁面上爬取到的每個 url 儲存到資料庫，為了避免重複，每次儲存前都要遍歷查詢資料庫中是否已經存在當前 url （即是否已經爬取過了）,若存在，則不儲存，否則，儲存當前 url ,繼續儲存下一條，直至結束。

2.將訪問過的ur儲存到set記憶體中

將訪問過的ur儲存到set中,只需要o(1)的代價就可以查詢url，取url方便快速，基本不用查詢，但是隨著儲存的url越來越多，佔用記憶體會越來越大。

1


# 簡單計算：假設有1億條url,每個url平均長度為50個字元，python裡unicode編碼，每個字元16位，佔2




2


# 個位元組（byte）




3


# 計算式：10^8 x 50個字元 x 2個byte / 1024 / 1024 / 1024 = 9G




4


#                                    B      M      G




5

如果是

2

億個url,那麼佔用記憶體將達

18

G，也不是特別方便，適合小型爬蟲。

3.url經過md5縮減到固定長度

 1


'''



 2

簡單計算：一個url經MD5轉換，變成一個128bit(位)的字串，佔16byte(位元組)，方法二中一個url保守



 3

估計佔50個字元 x 2 = 100byte(位元組)，



 4

計算式： 這樣一比較，MD5的空間節省率為：（100-16）/100 = 84%（相比於方法二）



 5

(Scrapy框架url去重就是採用的類似方法)



 6

'''




 7


# 維基百科看MD5演算法




 8


'''



 9

MD5概述



10

設計者 : 羅納德·李維斯特



11

首次釋出 : 1992年4月



12

系列 : MD, MD2, MD3, MD4, MD5



13

編碼長度 : 128位



14

結構 :　Merkle–Damgård construction



15

    MD5訊息摘要演算法（英語：MD5 Message-Digest Algorithm），一種被廣泛使用的密碼雜湊函式，可



16

以產生出一個128位（16位元組）的雜湊值（hash value），用於確保資訊傳輸完整一致。MD5由美國密碼學家



17

羅納德·李維斯特（Ronald Linn Rivest）設計，於1992年公開，用以取代MD4演算法。這套演算法的程式在 



18

RFC 1321 中被加以規範。



19

將資料（如一段文字）運算變為另一固定長度值，是雜湊演算法的基礎原理。



20

'''

MD5使用例項：

 1


# 在python3中使用hashlib模組進行md5操作




 2


import

 hashlib



 3




 4


# 待加密資訊




 5

str01 = 

'This is your md5 password!'




 6


# 建立md5物件




 7

md5_obj = hashlib.md5()



 8


# 進行MD5加密前必須 encode(編碼)，python裡預設是unicode編碼，必須轉換成utf-8




 9


# 否則報錯：TypeError: Unicode-objects must be encoded before hashing




10

md5_obj.update(str01.encode(encoding=

'utf-8'

))



11




12

print(

'XksA的原話為 ：'

 + str01)



13

print(

'MD5加密後為 ：'

 + md5_obj.hexdigest())



14




15


# result　：




16


#        XksA的原話為 ：This is your md5 password!




17


#        MD5加密後為 ：0a5f76e7b0f352e47fed559f904c9159

4.用 bitmap方法,將訪問過的ur透過hash函式對映到某一位

 1


'''



 2

實現原理：透過hash函式，將每個url對映到一個hash位置中，一個hash位可以只佔用一個bit(位)大小，那



 3

麼相對於方法三：一個url佔128bit(位)，hash函式法的空間節省成百倍增長。



 4

計算式：這樣一比較，bitmap方法的空間節省率為：



 5

（128-1）/128= 99.2%(相比於方法三)



 6

（100 * 8 - 1）/（100*8）= 99.88%（相比於方法一）



 7

                       ##   (缺點：容易產生衝突)  ##



 8

'''




 9


# 維基百科看Hash 函式




10


'''



11

hash函式：



12

雜湊函式（英語：Hash function）又稱雜湊演算法、雜湊函式，是一種從任何一種資料中建立小的數字“指紋”



13

的方法。雜湊函式把訊息或資料壓縮成摘要，使得資料量變小，將資料的格式固定下來。該函式將資料打亂混



14

合，重新建立一個叫做雜湊值（hash values，hash codes，hash sums，或hashes）的指紋。雜湊值通常



15

用一個短的隨機字母和數字組成的字串來代表。好的雜湊函式在輸入域中很少出現雜湊衝突。在雜湊表和數



16

據處理中，不抑制衝突來區別資料，會使得資料庫記錄更難找到。



17

'''

5.bloomfilter方法對 bitmap進行改進,多重hash函式降低衝突

 1


# 維基百科看Bloomfilter




 2


'''



 3

# 基本概述



 4

   如果想判斷一個元素是不是在一個集合裡，一般想到的是將集合中所有元素儲存起來，然後透過比較確定。



 5

連結串列、樹、雜湊表（又叫雜湊表，Hash table）等等資料結構都是這種思路。但是隨著集合中元素的增加，



 6

我們需要的儲存空間越來越大。同時檢索速度也越來越慢，上述三種結構的檢索時間複雜度分別為：



 7

                            O(n),O(log n),O(n/k)



 8

# 原理概述



 9

   布隆過濾器的原理是，當一個元素被加入集合時，透過K個雜湊函式將這個元素對映成一個位陣列中的K個



10

點，把它們置為1。檢索時，我們只要看看這些點是不是都是1就（大約）知道集合中有沒有它了：如果這些點



11

有任何一個0，則被檢元素一定不在；如果都是1，則被檢元素很可能在。這就是布隆過濾器的基本思想。



12

# 優缺點



13

    布隆過濾器可以用於檢索一個元素是否在一個集合中。



14

    優點是空間效率和查詢時間都遠遠超過一般的演算法。



15

    缺點是有一定的誤識別率和刪除困難。



16

'''




17


# Bloomfilter介紹還可以看這裡：https://blog.csdn.net/preyta/article/details/72804148

Bloomfilter底層實現：

 1


# 原始碼地址：




 2


import

 math



 3


import

 logging



 4


import

 functools



 5




 6


import

 pyhash



 7




 8


from

 bitset 

import

 MmapBitSet



 9


from

 hash_tools 

import

 hashes



10




11




12



class

 

BloomFilter


(object)

:




13

    

"""



14

    A bloom filter implementation,



15

    which use Murmur hash and Spooky hash



16

    """




17

    


def

 

__init__


(self, capacity, error_rate=

0.0001

, fname=None,



18

                 h1=pyhash.murmur3_x64_128

()

, h2=pyhash.spooky_128

()

)

:




19

        

"""



20

        :param capacity: size of possible input elements



21

        :param error_rate: posi



22

        :param fname:



23

        :param h1:



24

        :param h2:



25

        """




26

        

# calculate m & k




27

        self.capacity = capacity



28

        self.error_rate = error_rate



29

        self.num_of_bits, self.num_of_hashes = self._adjust_param(

4096

 * 

8

,



30

                                                                  error_rate)



31

        self._fname = fname



32

        self._data_store = MmapBitSet(self.num_of_bits)



33

        self._size = len(self._data_store)



34

        self._hashes = functools.partial(hashes, h1=h1, h2=h2, number=self.num_of_hashes)



35




36

    


def

 

_adjust_param


(self, bits_size, expected_error_rate)

:




37

        

"""



38

        adjust k & m through 4 steps:



39

        1. Choose a ballpark value for n



40

        2. Choose a value for m



41

        3. Calculate the optimal value of k



42

        4. Calculate the error rate for our chosen values of n, m, and k.



43

           If it's unacceptable, return to step 2 and change m;



44

           otherwise we're done.



45

        in every loop, m = m * 2



46

        :param bits_size:



47

        :param expected_error_rate:



48

        :return:



49

        """




50

        n, estimated_m, estimated_k, error_rate = self.capacity, int(bits_size / 

2

), 

None

, 

1




51

        weight, e = math.log(

2

), math.exp(

1

)



52

        

while

 error_rate > expected_error_rate:



53

            estimated_m *= 

2




54

            estimated_k = int((float(estimated_m) / n) * weight) + 

1




55

            error_rate = (

1

 - math.exp(- (estimated_k * n) / estimated_m)) ** estimated_k



56

            logging.info(estimated_m, estimated_k, error_rate)



57

        

return

 estimated_m, estimated_k



58




59

    


def

 

add


(self, msg)

:




60

        

"""



61

        add a string to bloomfilter



62

        :param msg:



63

        :return:



64

        """




65

        

if

 

not

 isinstance(msg, str):



66

            msg = str(msg)



67

        positions = []



68

        

for

 _hash_value 

in

 self._hashes(msg):



69

            positions.append(_hash_value % self.num_of_bits)



70

        

for

 pos 

in

 sorted(positions):



71

            self._data_store.set(int(pos))



72




73

    @staticmethod



74

    


def

 

open


(self, fname)

:




75

        

with

 open(fname) 

as

 fp:



76

            

raise

 NotImplementedError



77




78

    


def

 

__str__


(self)

:




79

        

"""



80

        output bitset directly



81

        :return:



82

        """




83

        

pass




84




85

    


def

 

__contains__


(self, msg)

:




86

        

if

 

not

 isinstance(msg, str):



87

            msg = str(msg)



88

        positions = []



89

        

for

 _hash_value 

in

 self._hashes(msg):



90

            positions.append(_hash_value % self.num_of_bits)



91

        

for

 position 

in

 sorted(positions):



92

            

if

 

not

 self._data_store.test(position):



93

                

return

 

False




94

        

return

 

True




95




96

    


def

 

__len__


(self)

:




97

        

return

 self._size

四、後言

    學完這一期，我覺得，是時候拿起高數書，線代書，機率論，離散數學…好好學習數學了，哈哈哈！

附贈：七夕快樂大家。