當前位置:首頁 » 編程語言 » 爬蟲python代碼

爬蟲python代碼

發布時間: 2022-10-05 00:30:28

1. 如何用python編寫一個簡單的爬蟲

以下代碼運行通過:

importre
importrequests


defShowCity():
html=requests.get("http://www.tianqihoubao.com/weather/province.aspx?id=110000")
citys=re.findall('<tdstyle="height:22px"align="center"><ahref="http://blog.163.com/lucia_gagaga/blog/(.*?)">',html.text,re.S)
forcityincitys:
print(city)

ShowCity()

運行效果:

2. 有沒有易懂的 Python 多線程爬蟲代碼

Python 在程序並行化方面多少有些聲名狼藉。撇開技術上的問題,例如線程的實現和 GIL1,我覺得錯誤的教學指導才是主要問題。常見的經典 Python 多線程、多進程教程多顯得偏「重」。而且往往隔靴搔癢,沒有深入探討日常工作中最有用的內容。
傳統的例子
簡單搜索下「Python 多線程教程」,不難發現幾乎所有的教程都給出涉及類和隊列的例子:
#Example.py
'''
Standard Procer/Consumer Threading Pattern
'''

import time
import threading
import Queue

class Consumer(threading.Thread):
def __init__(self, queue):
threading.Thread.__init__(self)
self._queue = queue

def run(self):
while True:
# queue.get() blocks the current thread until
# an item is retrieved.
msg = self._queue.get()
# Checks if the current message is
# the "Poison Pill"
if isinstance(msg, str) and msg == 'quit':
# if so, exists the loop
break
# "Processes" (or in our case, prints) the queue item
print "I'm a thread, and I received %s!!" % msg
# Always be friendly!
print 'Bye byes!'

def Procer():
# Queue is used to share items between
# the threads.
queue = Queue.Queue()

# Create an instance of the worker
worker = Consumer(queue)
# start calls the internal run() method to
# kick off the thread
worker.start()

# variable to keep track of when we started
start_time = time.time()
# While under 5 seconds..
while time.time() - start_time < 5:
# "Proce" a piece of work and stick it in
# the queue for the Consumer to process
queue.put('something at %s' % time.time())
# Sleep a bit just to avoid an absurd number of messages
time.sleep(1)

# This the "poison pill" method of killing a thread.
queue.put('quit')
# wait for the thread to close down
worker.join()

if __name__ == '__main__':
Procer()

哈,看起來有些像 Java 不是嗎?
我並不是說使用生產者/消費者模型處理多線程/多進程任務是錯誤的(事實上,這一模型自有其用武之地)。只是,處理日常腳本任務時我們可以使用更有效率的模型。
問題在於…
首先,你需要一個樣板類;
其次,你需要一個隊列來傳遞對象;
而且,你還需要在通道兩端都構建相應的方法來協助其工作(如果需想要進行雙向通信或是保存結果還需要再引入一個隊列)。
worker 越多,問題越多
按照這一思路,你現在需要一個 worker 線程的線程池。下面是一篇 IBM 經典教程中的例子——在進行網頁檢索時通過多線程進行加速。
#Example2.py
'''
A more realistic thread pool example
'''

import time
import threading
import Queue
import urllib2

class Consumer(threading.Thread):
def __init__(self, queue):
threading.Thread.__init__(self)
self._queue = queue

def run(self):
while True:
content = self._queue.get()
if isinstance(content, str) and content == 'quit':
break
response = urllib2.urlopen(content)
print 'Bye byes!'

def Procer():
urls = [
'', ''
'', ''
# etc..
]
queue = Queue.Queue()
worker_threads = build_worker_pool(queue, 4)
start_time = time.time()

# Add the urls to process
for url in urls:
queue.put(url)
# Add the poison pillv
for worker in worker_threads:
queue.put('quit')
for worker in worker_threads:
worker.join()

print 'Done! Time taken: {}'.format(time.time() - start_time)

def build_worker_pool(queue, size):
workers = []
for _ in range(size):
worker = Consumer(queue)
worker.start()
workers.append(worker)
return workers

if __name__ == '__main__':
Procer()

這段代碼能正確的運行,但仔細看看我們需要做些什麼:構造不同的方法、追蹤一系列的線程,還有為了解決惱人的死鎖問題,我們需要進行一系列的 join 操作。這還只是開始……
至此我們回顧了經典的多線程教程,多少有些空洞不是嗎?樣板化而且易出錯,這樣事倍功半的風格顯然不那麼適合日常使用,好在我們還有更好的方法。
何不試試 map
map 這一小巧精緻的函數是簡捷實現 Python 程序並行化的關鍵。map 源於 Lisp 這類函數式編程語言。它可以通過一個序列實現兩個函數之間的映射。
urls = ['', '']
results = map(urllib2.urlopen, urls)

上面的這兩行代碼將 urls 這一序列中的每個元素作為參數傳遞到 urlopen 方法中,並將所有結果保存到 results 這一列表中。其結果大致相當於:
results = []
for url in urls:
results.append(urllib2.urlopen(url))

map 函數一手包辦了序列操作、參數傳遞和結果保存等一系列的操作。
為什麼這很重要呢?這是因為藉助正確的庫,map 可以輕松實現並行化操作。

在 Python 中有個兩個庫包含了 map 函數: multiprocessing 和它鮮為人知的子庫 multiprocessing.mmy.
這里多扯兩句: multiprocessing.mmy? mltiprocessing 庫的線程版克隆?這是蝦米?即便在 multiprocessing 庫的官方文檔里關於這一子庫也只有一句相關描述。而這句描述譯成人話基本就是說:"嘛,有這么個東西,你知道就成."相信我,這個庫被嚴重低估了!
mmy 是 multiprocessing 模塊的完整克隆,唯一的不同在於 multiprocessing 作用於進程,而 mmy 模塊作用於線程(因此也包括了 Python 所有常見的多線程限制)。
所以替換使用這兩個庫異常容易。你可以針對 IO 密集型任務和 CPU 密集型任務來選擇不同的庫。2
動手嘗試
使用下面的兩行代碼來引用包含並行化 map 函數的庫:
from multiprocessing import Pool
from multiprocessing.mmy import Pool as ThreadPool

實例化 Pool 對象:
pool = ThreadPool()

這條簡單的語句替代了 example2.py 中 build_worker_pool 函數 7 行代碼的工作。它生成了一系列的 worker 線程並完成初始化工作、將它們儲存在變數中以方便訪問
Pool 對象有一些參數,這里我所需要關注的只是它的第一個參數:processes. 這一參數用於設定線程池中的線程數。其默認值為當前機器 CPU 的核數。
一般來說,執行 CPU 密集型任務時,調用越多的核速度就越快。但是當處理網路密集型任務時,事情有有些難以預計了,通過實驗來確定線程池的大小才是明智的。
pool = ThreadPool(4) # Sets the pool size to 4

線程數過多時,切換線程所消耗的時間甚至會超過實際工作時間。對於不同的工作,通過嘗試來找到線程池大小的最優值是個不錯的主意。
創建好 Pool 對象後,並行化的程序便呼之欲出了。我們來看看改寫後的 example2.py
import urllib2
from multiprocessing.mmy import Pool as ThreadPool

urls = [

# etc..
]

# Make the Pool of workers
pool = ThreadPool(4)
# Open the urls in their own threads
# and return the results
results = pool.map(urllib2.urlopen, urls)
#close the pool and wait for the work to finish
pool.close()
pool.join()

實際起作用的代碼只有 4 行,其中只有一行是關鍵的。map 函數輕而易舉的取代了前文中超過 40 行的例子。為了更有趣一些,我統計了不同方法、不同線程池大小的耗時情況。
# results = []
# for url in urls:
# result = urllib2.urlopen(url)
# results.append(result)

# # ------- VERSUS ------- #

# # ------- 4 Pool ------- #
# pool = ThreadPool(4)
# results = pool.map(urllib2.urlopen, urls)

# # ------- 8 Pool ------- #

# pool = ThreadPool(8)
# results = pool.map(urllib2.urlopen, urls)

# # ------- 13 Pool ------- #

# pool = ThreadPool(13)
# results = pool.map(urllib2.urlopen, urls)

結果:
# Single thread: 14.4 Seconds
# 4 Pool: 3.1 Seconds
# 8 Pool: 1.4 Seconds
# 13 Pool: 1.3 Seconds

很棒的結果不是嗎?這一結果也說明了為什麼要通過實驗來確定線程池的大小。在我的機器上當線程池大小大於 9 帶來的收益就十分有限了。
另一個真實的例子
生成上千張圖片的縮略圖
這是一個 CPU 密集型的任務,並且十分適合進行並行化。
基礎單進程版本
import os
import PIL

from multiprocessing import Pool
from PIL import Image

SIZE = (75,75)
SAVE_DIRECTORY = 'thumbs'

def get_image_paths(folder):
return (os.path.join(folder, f)
for f in os.listdir(folder)
if 'jpeg' in f)

def create_thumbnail(filename):
im = Image.open(filename)
im.thumbnail(SIZE, Image.ANTIALIAS)
base, fname = os.path.split(filename)
save_path = os.path.join(base, SAVE_DIRECTORY, fname)
im.save(save_path)

if __name__ == '__main__':
folder = os.path.abspath(
'11_18_2013_R000_IQM_Big_Sur_Mon__e10d1958e7b766c3e840')
os.mkdir(os.path.join(folder, SAVE_DIRECTORY))

images = get_image_paths(folder)

for image in images:
create_thumbnail(Image)

上邊這段代碼的主要工作就是將遍歷傳入的文件夾中的圖片文件,一一生成縮略圖,並將這些縮略圖保存到特定文件夾中。
這我的機器上,用這一程序處理 6000 張圖片需要花費 27.9 秒。
如果我們使用 map 函數來代替 for 循環:
import os
import PIL

from multiprocessing import Pool
from PIL import Image

SIZE = (75,75)
SAVE_DIRECTORY = 'thumbs'

def get_image_paths(folder):
return (os.path.join(folder, f)
for f in os.listdir(folder)
if 'jpeg' in f)

def create_thumbnail(filename):
im = Image.open(filename)
im.thumbnail(SIZE, Image.ANTIALIAS)
base, fname = os.path.split(filename)
save_path = os.path.join(base, SAVE_DIRECTORY, fname)
im.save(save_path)

if __name__ == '__main__':
folder = os.path.abspath(
'11_18_2013_R000_IQM_Big_Sur_Mon__e10d1958e7b766c3e840')
os.mkdir(os.path.join(folder, SAVE_DIRECTORY))

images = get_image_paths(folder)

pool = Pool()
pool.map(creat_thumbnail, images)
pool.close()
pool.join()

5.6 秒!
雖然只改動了幾行代碼,我們卻明顯提高了程序的執行速度。在生產環境中,我們可以為 CPU 密集型任務和 IO 密集型任務分別選擇多進程和多線程庫來進一步提高執行速度——這也是解決死鎖問題的良方。此外,由於 map 函數並不支持手動線程管理,反而使得相關的 debug 工作也變得異常簡單。
到這里,我們就實現了(基本)通過一行 Python 實現並行化。

3. 如何用Python做爬蟲

在我們日常上網瀏覽網頁的時候,經常會看到一些好看的圖片,我們就希望把這些圖片保存下載,或者用戶用來做桌面壁紙,或者用來做設計的素材。

我們最常規的做法就是通過滑鼠右鍵,選擇另存為。但有些圖片滑鼠右鍵的時候並沒有另存為選項,還有辦法就通過就是通過截圖工具截取下來,但這樣就降低圖片的清晰度。好吧其實你很厲害的,右鍵查看頁面源代碼。

我們可以通過python來實現這樣一個簡單的爬蟲功能,把我們想要的代碼爬取到本地。下面就看看如何使用python來實現這樣一個功能。

4. Python爬蟲如何寫

先檢查是否有API

API是網站官方提供的數據介面,如果通過調用API採集數據,則相當於在網站允許的范圍內採集,這樣既不會有道德法律風險,也沒有網站故意設置的障礙;不過調用API介面的訪問則處於網站的控制中,網站可以用來收費,可以用來限制訪問上限等。整體來看,如果數據採集的需求並不是很獨特,那麼有API則應優先採用調用API的方式。

數據結構分析和數據存儲

爬蟲需求要十分清晰,具體表現為需要哪些欄位,這些欄位可以是網頁上現有的,也可以是根據網頁上現有的欄位進一步計算的,這些欄位如何構建表,多張表如何連接等。值得一提的是,確定欄位環節,不要只看少量的網頁,因為單個網頁可以缺少別的同類網頁的欄位,這既有可能是由於網站的問題,也可能是用戶行為的差異,只有多觀察一些網頁才能綜合抽象出具有普適性的關鍵欄位——這並不是幾分鍾看幾個網頁就可以決定的簡單事情,如果遇上了那種臃腫、混亂的網站,可能坑非常多。

對於大規模爬蟲,除了本身要採集的數據外,其他重要的中間數據(比如頁面Id或者url)也建議存儲下來,這樣可以不必每次重新爬取id。

資料庫並沒有固定的選擇,本質仍是將Python里的數據寫到庫里,可以選擇關系型資料庫Mysql等,也可以選擇非關系型資料庫MongoDB等;對於普通的結構化數據一般存在關系型資料庫即可。sqlalchemy是一個成熟好用的資料庫連接框架,其引擎可與Pandas配套使用,把數據處理和數據存儲連接起來,一氣呵成。

數據流分析

對於要批量爬取的網頁,往上一層,看它的入口在哪裡;這個是根據採集范圍來確定入口,比如若只想爬一個地區的數據,那從該地區的主頁切入即可;但若想爬全國數據,則應更往上一層,從全國的入口切入。一般的網站網頁都以樹狀結構為主,找到切入點作為根節點一層層往裡進入即可。

值得注意的一點是,一般網站都不會直接把全量的數據做成列表給你一頁頁往下翻直到遍歷完數據,比如鏈家上面很清楚地寫著有24587套二手房,但是它只給100頁,每頁30個,如果直接這么切入只能訪問3000個,遠遠低於真實數據量;因此先切片,再整合的數據思維可以獲得更大的數據量。顯然100頁是系統設定,只要超過300個就只顯示100頁,因此可以通過其他的篩選條件不斷細分,只到篩選結果小於等於300頁就表示該條件下沒有缺漏;最後把各種條件下的篩選結果集合在一起,就能夠盡可能地還原真實數據量。

明確了大規模爬蟲的數據流動機制,下一步就是針對單個網頁進行解析,然後把這個模式復制到整體。對於單個網頁,採用抓包工具可以查看它的請求方式,是get還是post,有沒有提交表單,欲採集的數據是寫入源代碼里還是通過AJAX調用JSON數據。

同樣的道理,不能只看一個頁面,要觀察多個頁面,因為批量爬蟲要弄清這些大量頁面url以及參數的規律,以便可以自動構造;有的網站的url以及關鍵參數是加密的,這樣就悲劇了,不能靠著明顯的邏輯直接構造,這種情況下要批量爬蟲,要麼找到它加密的js代碼,在爬蟲代碼上加入從明文到密碼的加密過程;要麼採用下文所述的模擬瀏覽器的方式。

數據採集

之前用R做爬蟲,不要笑,R的確可以做爬蟲工作;但在爬蟲方面,Python顯然優勢更明顯,受眾更廣,這得益於其成熟的爬蟲框架,以及其他的在計算機系統上更好的性能。scrapy是一個成熟的爬蟲框架,直接往裡套用就好,比較適合新手學習;requests是一個比原生的urllib包更簡潔強大的包,適合作定製化的爬蟲功能。requests主要提供一個基本訪問功能,把網頁的源代碼給download下來。一般而言,只要加上跟瀏覽器同樣的Requests Headers參數,就可以正常訪問,status_code為200,並成功得到網頁源代碼;但是也有某些反爬蟲較為嚴格的網站,這么直接訪問會被禁止;或者說status為200也不會返回正常的網頁源碼,而是要求寫驗證碼的js腳本等。

下載到了源碼之後,如果數據就在源碼中,這種情況是最簡單的,這就表示已經成功獲取到了數據,剩下的無非就是數據提取、清洗、入庫。但若網頁上有,然而源代碼里沒有的,就表示數據寫在其他地方,一般而言是通過AJAX非同步載入JSON數據,從XHR中找即可找到;如果這樣還找不到,那就需要去解析js腳本了。

解析工具

源碼下載後,就是解析數據了,常用的有兩種方法,一種是用BeautifulSoup對樹狀HTML進行解析,另一種是通過正則表達式從文本中抽取數據。

BeautifulSoup比較簡單,支持Xpath和CSSSelector兩種途徑,而且像Chrome這類瀏覽器一般都已經把各個結點的Xpath或者CSSSelector標記好了,直接復制即可。以CSSSelector為例,可以選擇tag、id、class等多種方式進行定位選擇,如果有id建議選id,因為根據HTML語法,一個id只能綁定一個標簽。

正則表達式很強大,但構造起來有點復雜,需要專門去學習。因為下載下來的源碼格式就是字元串,所以正則表達式可以大顯身手,而且處理速度很快。

對於HTML結構固定,即同樣的欄位處tag、id和class名稱都相同,採用BeautifulSoup解析是一種簡單高效的方案,但有的網站混亂,同樣的數據在不同頁面間HTML結構不同,這種情況下BeautifulSoup就不太好使;如果數據本身格式固定,則用正則表達式更方便。比如以下的例子,這兩個都是深圳地區某個地方的經度,但一個頁面的class是long,一個頁面的class是longitude,根據class來選擇就沒辦法同時滿足2個,但只要注意到深圳地區的經度都是介於113到114之間的浮點數,就可以通過正則表達式"11[3-4].\d+"來使兩個都滿足。

數據整理

一般而言,爬下來的原始數據都不是清潔的,所以在入庫前要先整理;由於大部分都是字元串,所以主要也就是字元串的處理方式了。

字元串自帶的方法可以滿足大部分簡單的處理需求,比如strip可以去掉首尾不需要的字元或者換行符等,replace可以將指定部分替換成需要的部分,split可以在指定部分分割然後截取一部分。

如果字元串處理的需求太復雜以致常規的字元串處理方法不好解決,那就要請出正則表達式這個大殺器。

Pandas是Python中常用的數據處理模塊,雖然作為一個從R轉過來的人一直覺得這個模仿R的包實在是太難用了。Pandas不僅可以進行向量化處理、篩選、分組、計算,還能夠整合成DataFrame,將採集的數據整合成一張表,呈現最終的存儲效果。

寫入資料庫

如果只是中小規模的爬蟲,可以把最後的爬蟲結果匯合成一張表,最後導出成一張表格以便後續使用;但對於表數量多、單張表容量大的大規模爬蟲,再導出成一堆零散的表就不合適了,肯定還是要放在資料庫中,既方便存儲,也方便進一步整理。

寫入資料庫有兩種方法,一種是通過Pandas的DataFrame自帶的to_sql方法,好處是自動建表,對於對表結構沒有嚴格要求的情況下可以採用這種方式,不過值得一提的是,如果是多行的DataFrame可以直接插入不加索引,但若只有一行就要加索引否則報錯,雖然這個認為不太合理;另一種是利用資料庫引擎來執行SQL語句,這種情況下要先自己建表,雖然多了一步,但是表結構完全是自己控制之下。Pandas與SQL都可以用來建表、整理數據,結合起來使用效率更高。

5. 為什麼都說爬蟲PYTHON好

選擇Python作為實現爬蟲的語言,其主要考慮因素在於:
(1) 抓取網頁本身的介面
相比其他動態腳本語言(如Perl、Shell),Python的urllib2包提供了較為完整的訪問網頁文檔的API;相比與其他靜態編程語言(如Java、C#、C++),Python抓取網頁文檔的介面更簡潔。
此外,抓取網頁有時候需要模擬瀏覽器的行為,很多網站對於生硬的爬蟲抓取都是封殺的。這時我們需要模擬User Agent的行為構造合適的請求,譬如模擬用戶登錄、模擬Session/Cookie的存儲和設置。在Python里都有非常優秀的第三方包幫你搞定,如Requests或Mechanize。
(2) 網頁抓取後的處理
抓取的網頁通常需要處理,比如過濾Html標簽,提取文本等。Python的Beautiful Soup提供了簡潔的文檔處理功能,能用極短的代碼完成大部分文檔的處理。
其實以上功能很多語言和工具都能做,但是用Python能夠幹得最快、最干凈,正如這句「Life is short,you need Python」。
(3) 開發效率高
因為爬蟲的具體代碼根據網站不同而修改的,而Python這種靈活的腳本語言特別適合這種任務。
(4) 上手快
網路上Python的教學資源很多,便於大家學習,出現問題也很容易找到相關資料。另外,Python還有強大的成熟爬蟲框架的支持,比如Scrapy。

6. Python爬蟲是什麼

爬蟲一般指網路資源的抓取,通過編程語言撰寫爬蟲工具,抓取自己想要的數據以及內容。而在眾多編程語言之中,Python有豐富的網路抓取模塊,因此成為撰寫爬蟲的首選語言,並引起了學習熱潮。
Python作為一門編程語言而純粹的自由軟體,以簡潔清晰的語法和強制使用空白符號進行語句縮進的特點受到程序員的喜愛。用不同編程語言完成一個任務,C語言一共要寫1000行代碼,Java要寫100行代碼,而Python只需要20行,用Python來完成編程任務代碼量更少,代碼簡潔簡短而且可讀性強。
Python非常適合開發網路爬蟲,因為對比其他靜態編程語言,Python抓取網頁文檔的介面更簡潔;對比其他腳本語言,Python的urllib2包提供了較為完整的訪問網頁文檔的API。
Python爬蟲的工作流程是什麼?
Python爬蟲通過URL管理器,判斷是否有待爬URL,如果有待爬URL,通過調度器進行傳遞給下載器,下載URL內容,通過調度器傳送給解釋器,解析URL內容,將有價值數據和新的URL列表通過調度器傳遞給應用程序,輸出價值信息的過程。
Python是一門非常適合開發網路爬蟲的語言,提供了urllib、re、json、pyquery等模塊,同時還有很多成型框架,比如說Scrapy框架、PySpider爬蟲系統等,代碼十分簡潔方便,是新手學習網路爬蟲的首選語言。

7. python 爬蟲代碼 有了爬蟲代碼怎麼運行

  • 打開python爬蟲代碼的源碼目錄,通常開始文件為,init.py,start.py,app.py尋找有沒有類似的python文件,如果沒有,請看源碼的readme文件,裡面會有說明,若以上都沒有,你可能需要python方面的知識,自己去看源碼,找到入口方法並運行

  • 找到入口文件後,在當前目錄打開控制台,輸入python

    正常情況下會出現下圖的提示,若沒有,請檢查當前pc的python環境是否有被正確安裝

  • 最後,運行入口文件,輸入python ***.py(入口文件),運行爬蟲

8. 有沒有易懂的 Python 多線程爬蟲代碼

Python 在程序並行化方面多少有些聲名狼藉。撇開技術上的問題,例如線程的實現和 GIL1,我覺得錯誤的教學指導才是主要問題。常見的經典 Python 多線程、多進程教程多顯得偏「重」。而且往往隔靴搔癢,沒有深入探討日常工作中最有用的內容。
傳統的例子
簡單搜索下「Python 多線程教程」,不難發現幾乎所有的教程都給出涉及類和隊列的例子:
#Example.py'''
Standard Procer/Consumer Threading Pattern
'''import time
import threading
import Queue

class Consumer(threading.Thread):
def __init__(self, queue):
threading.Thread.__init__(self)
self._queue = queue

def run(self):
while True:
# queue.get() blocks the current thread until
# an item is retrieved.
msg = self._queue.get()
# Checks if the current message is
# the "Poison Pill"
if isinstance(msg, str) and msg == 'quit': # if so, exists the loop
break
# "Processes" (or in our case, prints) the queue item
print "I'm a thread, and I received %s!!" % msg # Always be friendly!
print 'Bye byes!'def Procer():
# Queue is used to share items between
# the threads.
queue = Queue.Queue() # Create an instance of the worker
worker = Consumer(queue) # start calls the internal run() method to
# kick off the thread
worker.start()

# variable to keep track of when we started
start_time = time.time()
# While under 5 seconds..
while time.time() - start_time < 5:
# "Proce" a piece of work and stick it in
# the queue for the Consumer to process
queue.put('something at %s' % time.time()) # Sleep a bit just to avoid an absurd number of messages
time.sleep(1) # This the "poison pill" method of killing a thread.
queue.put('quit') # wait for the thread to close down
worker.join()if __name__ == '__main__':
Procer()

哈,看起來有些像 Java 不是嗎?
我並不是說使用生產者/消費者模型處理多線程/多進程任務是錯誤的(事實上,這一模型自有其用武之地)。只是,處理日常腳本任務時我們可以使用更有效率的模型。
問題在於…
首先,你需要一個樣板類;
其次,你需要一個隊列來傳遞對象;
而且,你還需要在通道兩端都構建相應的方法來協助其工作(如果需想要進行雙向通信或是保存結果還需要再引入一個隊列)。
worker 越多,問題越多
按照這一思路,你現在需要一個 worker 線程的線程池。下面是一篇 IBM 經典教程中的例子——在進行網頁檢索時通過多線程進行加速。
#Example2.py'''
A more realistic thread pool example
'''import time
import threading
import Queue
import urllib2

class Consumer(threading.Thread):
def __init__(self, queue):
threading.Thread.__init__(self)
self._queue = queue

def run(self):
while True:
content = self._queue.get()
if isinstance(content, str) and content == 'quit': break
response = urllib2.urlopen(content) print 'Bye byes!'def Procer():
urls = [ 'http', 'httcom'
'ala.org', 'hle.com'
# etc..
]
queue = Queue.Queue()
worker_threads = build_worker_pool(queue, 4)
start_time = time.time() # Add the urls to process
for url in urls:
queue.put(url)
# Add the poison pillv
for worker in worker_threads:
queue.put('quit') for worker in worker_threads:
worker.join() print 'Done! Time taken: {}'.format(time.time() - start_time)def build_worker_pool(queue, size):
workers = [] for _ in range(size):
worker = Consumer(queue)
worker.start()
workers.append(worker) return workersif __name__ == '__main__':
Procer()

這段代碼能正確的運行,但仔細看看我們需要做些什麼:構造不同的方法、追蹤一系列的線程,還有為了解決惱人的死鎖問題,我們需要進行一系列的 join 操作。這還只是開始……
至此我們回顧了經典的多線程教程,多少有些空洞不是嗎?樣板化而且易出錯,這樣事倍功半的風格顯然不那麼適合日常使用,好在我們還有更好的方法。
何不試試 map
map 這一小巧精緻的函數是簡捷實現 Python 程序並行化的關鍵。map 源於 Lisp 這類函數式編程語言。它可以通過一個序列實現兩個函數之間的映射。
urls = ['ho.com', 'htdit.com']
results = map(urllib2.urlopen, urls)

上面的這兩行代碼將 urls 這一序列中的每個元素作為參數傳遞到 urlopen 方法中,並將所有結果保存到 results 這一列表中。其結果大致相當於:
results = []for url in urls:
results.append(urllib2.urlopen(url))

map 函數一手包辦了序列操作、參數傳遞和結果保存等一系列的操作。
為什麼這很重要呢?這是因為藉助正確的庫,map 可以輕松實現並行化操作。

在 Python 中有個兩個庫包含了 map 函數: multiprocessing 和它鮮為人知的子庫 multiprocessing.mmy.
這里多扯兩句: multiprocessing.mmy? mltiprocessing 庫的線程版克隆?這是蝦米?即便在 multiprocessing 庫的官方文檔里關於這一子庫也只有一句相關描述。而這句描述譯成人話基本就是說:"嘛,有這么個東西,你知道就成."相信我,這個庫被嚴重低估了!
mmy 是 multiprocessing 模塊的完整克隆,唯一的不同在於 multiprocessing 作用於進程,而 mmy 模塊作用於線程(因此也包括了 Python 所有常見的多線程限制)。
所以替換使用這兩個庫異常容易。你可以針對 IO 密集型任務和 CPU 密集型任務來選擇不同的庫。2
動手嘗試
使用下面的兩行代碼來引用包含並行化 map 函數的庫:
from multiprocessing import Poolfrom multiprocessing.mmy import Pool as ThreadPool

實例化 Pool 對象:
pool = ThreadPool()

這條簡單的語句替代了 example2.py 中 build_worker_pool 函數 7 行代碼的工作。它生成了一系列的 worker 線程並完成初始化工作、將它們儲存在變數中以方便訪問。
Pool 對象有一些參數,這里我所需要關注的只是它的第一個參數:processes. 這一參數用於設定線程池中的線程數。其默認值為當前機器 CPU 的核數。
一般來說,執行 CPU 密集型任務時,調用越多的核速度就越快。但是當處理網路密集型任務時,事情有有些難以預計了,通過實驗來確定線程池的大小才是明智的。
pool = ThreadPool(4) # Sets the pool size to 4

線程數過多時,切換線程所消耗的時間甚至會超過實際工作時間。對於不同的工作,通過嘗試來找到線程池大小的最優值是個不錯的主意。
創建好 Pool 對象後,並行化的程序便呼之欲出了。我們來看看改寫後的 example2.py
import urllib2
from multiprocessing.mmy import Pool as ThreadPool

urls = [ 'httorg',
'hon.org/about/',
'hnlamp.com/pub/a/python/2003/04/17/metaclasses.html',

# etc..
]

# Make the Pool of workers
pool = ThreadPool(4)
# Open the urls in their own threads
# and return the results
results = pool.map(urllib2.urlopen, urls)
#close the pool and wait for the work to finish
pool.close()
pool.join()

實際起作用的代碼只有 4 行,其中只有一行是關鍵的。map 函數輕而易舉的取代了前文中超過 40 行的例子。為了更有趣一些,我統計了不同方法、不同線程池大小的耗時情況。
# results = [] # for url in urls:# result = urllib2.urlopen(url)# results.append(result)# # ------- VERSUS ------- # # # ------- 4 Pool ------- # # pool = ThreadPool(4) # results = pool.map(urllib2.urlopen, urls)# # ------- 8 Pool ------- # # pool = ThreadPool(8) # results = pool.map(urllib2.urlopen, urls)# # ------- 13 Pool ------- # # pool = ThreadPool(13) # results = pool.map(urllib2.urlopen, urls)

結果:
# Single thread: 14.4 Seconds # 4 Pool: 3.1 Seconds# 8 Pool: 1.4 Seconds# 13 Pool: 1.3 Seconds

很棒的結果不是嗎?這一結果也說明了為什麼要通過實驗來確定線程池的大小。在我的機器上當線程池大小大於 9 帶來的收益就十分有限了。

9. python爬蟲是什麼

Python爬蟲是指在某種原因進行互聯網請求獲取信息

10. 如何用Python做爬蟲

1)首先你要明白爬蟲怎樣工作。

想像你是一隻蜘蛛,現在你被放到了互聯「網」上。那麼,你需要把所有的網頁都看一遍。怎麼辦呢?沒問題呀,你就隨便從某個地方開始,比如說人民日報的首頁,這個叫initial pages,用$表示吧。

在人民日報的首頁,你看到那個頁面引向的各種鏈接。於是你很開心地從爬到了「國內新聞」那個頁面。太好了,這樣你就已經爬完了倆頁面(首頁和國內新聞)!暫且不用管爬下來的頁面怎麼處理的,你就想像你把這個頁面完完整整抄成了個html放到了你身上。

突然你發現, 在國內新聞這個頁面上,有一個鏈接鏈回「首頁」。作為一隻聰明的蜘蛛,你肯定知道你不用爬回去的吧,因為你已經看過了啊。所以,你需要用你的腦子,存下你已經看過的頁面地址。這樣,每次看到一個可能需要爬的新鏈接,你就先查查你腦子里是不是已經去過這個頁面地址。如果去過,那就別去了。

好的,理論上如果所有的頁面可以從initial page達到的話,那麼可以證明你一定可以爬完所有的網頁。

那麼在python里怎麼實現呢?
很簡單

import Queue

initial_page = "初始化頁"

url_queue = Queue.Queue()
seen = set()

seen.insert(initial_page)
url_queue.put(initial_page)

while(True): #一直進行直到海枯石爛
if url_queue.size()>0:
current_url = url_queue.get() #拿出隊例中第一個的url
store(current_url) #把這個url代表的網頁存儲好
for next_url in extract_urls(current_url): #提取把這個url里鏈向的url
if next_url not in seen:
seen.put(next_url)
url_queue.put(next_url)
else:
break

寫得已經很偽代碼了。

所有的爬蟲的backbone都在這里,下面分析一下為什麼爬蟲事實上是個非常復雜的東西——搜索引擎公司通常有一整個團隊來維護和開發。

2)效率
如果你直接加工一下上面的代碼直接運行的話,你需要一整年才能爬下整個豆瓣的內容。更別說Google這樣的搜索引擎需要爬下全網的內容了。

問題出在哪呢?需要爬的網頁實在太多太多了,而上面的代碼太慢太慢了。設想全網有N個網站,那麼分析一下判重的復雜度就是N*log(N),因為所有網頁要遍歷一次,而每次判重用set的話需要log(N)的復雜度。OK,OK,我知道python的set實現是hash——不過這樣還是太慢了,至少內存使用效率不高。

通常的判重做法是怎樣呢?Bloom Filter. 簡單講它仍然是一種hash的方法,但是它的特點是,它可以使用固定的內存(不隨url的數量而增長)以O(1)的效率判定url是否已經在set中。可惜天下沒有白吃的午餐,它的唯一問題在於,如果這個url不在set中,BF可以100%確定這個url沒有看過。但是如果這個url在set中,它會告訴你:這個url應該已經出現過,不過我有2%的不確定性。注意這里的不確定性在你分配的內存足夠大的時候,可以變得很小很少。一個簡單的教程:Bloom Filters by Example

注意到這個特點,url如果被看過,那麼可能以小概率重復看一看(沒關系,多看看不會累死)。但是如果沒被看過,一定會被看一下(這個很重要,不然我們就要漏掉一些網頁了!)。 [IMPORTANT: 此段有問題,請暫時略過]

好,現在已經接近處理判重最快的方法了。另外一個瓶頸——你只有一台機器。不管你的帶寬有多大,只要你的機器下載網頁的速度是瓶頸的話,那麼你只有加快這個速度。用一台機子不夠的話——用很多台吧!當然,我們假設每台機子都已經進了最大的效率——使用多線程(python的話,多進程吧)。

3)集群化抓取
爬取豆瓣的時候,我總共用了100多台機器晝夜不停地運行了一個月。想像如果只用一台機子你就得運行100個月了...

那麼,假設你現在有100台機器可以用,怎麼用python實現一個分布式的爬取演算法呢?

我們把這100台中的99台運算能力較小的機器叫作slave,另外一台較大的機器叫作master,那麼回顧上面代碼中的url_queue,如果我們能把這個queue放到這台master機器上,所有的slave都可以通過網路跟master聯通,每當一個slave完成下載一個網頁,就向master請求一個新的網頁來抓取。而每次slave新抓到一個網頁,就把這個網頁上所有的鏈接送到master的queue里去。同樣,bloom filter也放到master上,但是現在master只發送確定沒有被訪問過的url給slave。Bloom Filter放到master的內存里,而被訪問過的url放到運行在master上的Redis里,這樣保證所有操作都是O(1)。(至少平攤是O(1),Redis的訪問效率見:LINSERT – Redis)

考慮如何用python實現:
在各台slave上裝好scrapy,那麼各台機子就變成了一台有抓取能力的slave,在master上裝好Redis和rq用作分布式隊列。

代碼於是寫成

#slave.py

current_url = request_from_master()
to_send = []
for next_url in extract_urls(current_url):
to_send.append(next_url)

store(current_url);
send_to_master(to_send)

#master.py
distributed_queue = DistributedQueue()
bf = BloomFilter()

initial_pages = "www.renmingribao.com"

while(True):
if request == 'GET':
if distributed_queue.size()>0:
send(distributed_queue.get())
else:
break
elif request == 'POST':
bf.put(request.url)

好的,其實你能想到,有人已經給你寫好了你需要的:darkrho/scrapy-redis · GitHub

4)展望及後處理
雖然上面用很多「簡單」,但是真正要實現一個商業規模可用的爬蟲並不是一件容易的事。上面的代碼用來爬一個整體的網站幾乎沒有太大的問題。

但是如果附加上你需要這些後續處理,比如

有效地存儲(資料庫應該怎樣安排)

有效地判重(這里指網頁判重,咱可不想把人民日報和抄襲它的大民日報都爬一遍)

有效地信息抽取(比如怎麼樣抽取出網頁上所有的地址抽取出來,「朝陽區奮進路中華道」),搜索引擎通常不需要存儲所有的信息,比如圖片我存來幹嘛...

及時更新(預測這個網頁多久會更新一次)

如你所想,這里每一個點都可以供很多研究者十數年的研究。雖然如此,
「路漫漫其修遠兮,吾將上下而求索」。

所以,不要問怎麼入門,直接上路就好了:)

熱點內容
我的世界主要建造地皮的伺服器 發布:2022-12-07 00:17:42 瀏覽:426
iphoneqq聊天記錄文件夾 發布:2022-12-07 00:17:09 瀏覽:299
輔助源碼平台 發布:2022-12-07 00:17:03 瀏覽:133
登陸注冊源碼 發布:2022-12-07 00:09:55 瀏覽:968
上傳高延遲 發布:2022-12-07 00:08:33 瀏覽:51
電腦配置對比怎麼看 發布:2022-12-07 00:02:52 瀏覽:735
目前較高性能的電腦都有哪些配置 發布:2022-12-07 00:02:39 瀏覽:497
FTP客戶端編程有界面 發布:2022-12-07 00:00:29 瀏覽:590
一開機就跳出ftp 發布:2022-12-06 23:59:14 瀏覽:843
java的jlabel 發布:2022-12-06 23:59:09 瀏覽:730