天才教育網(wǎng)合作機構>

                                                                                        全國python學(xué)習中心

                                                                                        歡迎您!
                                                                                        朋友圈

                                                                                        400-850-8622

                                                                                        全國統一學(xué)習專(zhuān)線(xiàn) 9:00-21:00

                                                                                        位置:學(xué)校資訊 > python簡(jiǎn)單爬蟲(chóng)

                                                                                        python簡(jiǎn)單爬蟲(chóng)

                                                                                        日期:2023-03-31 16:43:15     瀏覽:757    來(lái)源:全國python學(xué)習中心
                                                                                        核心提示:如何入門(mén) Python 爬蟲(chóng)現在之所以有這么多的小伙伴熱衷于爬蟲(chóng)技術(shù),無(wú)外乎是因為爬蟲(chóng)可以幫我們做很多事情,比如搜索引擎、采集數據、廣告過(guò)濾等,以Python為例,Python爬蟲(chóng)可以用于數據分析,在數據抓取方面發(fā)揮巨大

                                                                                        如何入門(mén) Python 爬蟲(chóng)

                                                                                        現在之所以有這么多的小伙伴熱衷于爬蟲(chóng)技術(shù),無(wú)外乎是因為爬蟲(chóng)可以幫我們做很多事情,比如搜索引擎、采集數據、廣告過(guò)濾等,以Python為例,Python爬蟲(chóng)可以用于數據分析,在數據抓取方面發(fā)揮巨大的作用。
                                                                                        但是這并不意味著(zhù)單純掌握一門(mén)Python語(yǔ)言,就對爬蟲(chóng)技術(shù)觸類(lèi)旁通,要學(xué)習的知識和規范還有喜很多,包括但不僅限于HTML 知識、HTTP/HTTPS 協(xié)議的基本知識、正則表達式、數據庫知識,常用抓包工具的使用、爬蟲(chóng)框架的使用等。而且涉及到大規模爬蟲(chóng),還需要了解分布式的概念、消息隊列、常用的數據結構和算法、緩存,甚至還包括機器學(xué)習的應用,大規模的系統背后都是靠很多技術(shù)來(lái)支撐的。
                                                                                        零基礎如何學(xué)爬蟲(chóng)技術(shù)?對于迷茫的初學(xué)者來(lái)說(shuō),爬蟲(chóng)技術(shù)起步學(xué)習階段,最重要的就是明確學(xué)習路徑,找準學(xué)習方法,唯有如此,在良好的學(xué)習習慣督促下,后期的系統學(xué)習才會(huì )事半功倍,游刃有余。
                                                                                        用Python寫(xiě)爬蟲(chóng),首先需要會(huì )Python,把基礎語(yǔ)法搞懂,知道怎么使用函數、類(lèi)和常用的數據結構如list、dict中的常用方法就算基本入門(mén)。作為入門(mén)爬蟲(chóng)來(lái)說(shuō),需要了解 HTTP協(xié)議的基本原理,雖然 HTTP 規范用一本書(shū)都寫(xiě)不完,但深入的內容可以放以后慢慢去看,理論與實(shí)踐相結合后期學(xué)習才會(huì )越來(lái)越輕松。關(guān)于爬蟲(chóng)學(xué)習的具體步驟,我大概羅列了以下幾大部分,大家可以參考:
                                                                                        網(wǎng)絡(luò )爬蟲(chóng)基礎知識:
                                                                                        爬蟲(chóng)的定義
                                                                                        爬蟲(chóng)的作用
                                                                                        Http協(xié)議
                                                                                        基本抓包工具(Fiddler)使用
                                                                                        Python模塊實(shí)現爬蟲(chóng):
                                                                                        urllib3、requests、lxml、bs4 模塊大體作用講解
                                                                                        使用requests模塊 get 方式獲取靜態(tài)頁(yè)面數據
                                                                                        使用requests模塊 post 方式獲取靜態(tài)頁(yè)面數據
                                                                                        使用requests模塊獲取 ajax 動(dòng)態(tài)頁(yè)面數據
                                                                                        使用requests模塊模擬登錄網(wǎng)站
                                                                                        使用Tesseract進(jìn)行驗證碼識別
                                                                                        Scrapy框架與Scrapy-Redis:
                                                                                        Scrapy 爬蟲(chóng)框架大體說(shuō)明
                                                                                        Scrapy spider 類(lèi)
                                                                                        Scrapy item 及 pipeline
                                                                                        Scrapy 類(lèi)
                                                                                        通過(guò)Scrapy-Redis 實(shí)現分布式爬蟲(chóng)
                                                                                        借助自動(dòng)化測試工具和瀏覽器爬取數據:
                                                                                        Selenium + PhantomJS 說(shuō)明及簡(jiǎn)單實(shí)例
                                                                                        Selenium + PhantomJS 實(shí)現網(wǎng)站登錄
                                                                                        Selenium + PhantomJS 實(shí)現動(dòng)態(tài)頁(yè)面數據爬取
                                                                                        爬蟲(chóng)項目實(shí)戰:
                                                                                        分布式爬蟲(chóng)+ 打造搜索引擎

                                                                                        Python爬蟲(chóng)是什么?

                                                                                        網(wǎng)絡(luò )爬蟲(chóng)(又被稱(chēng)為網(wǎng)頁(yè)蜘蛛,網(wǎng)絡(luò )機器人,在FOAF社區中間,更經(jīng)常的稱(chēng)為網(wǎng)頁(yè)追逐者),是一種按照一定的規則,自動(dòng)地抓取萬(wàn)維網(wǎng)信息的程序或者腳本。另外一些不常使用的名字還有螞蟻、自動(dòng)索引、模擬程序或者蠕蟲(chóng)。
                                                                                        其實(shí)通俗的講就是通過(guò)程序去獲取web頁(yè)面上自己想要的數據,也就是自動(dòng)抓取數據。
                                                                                        爬蟲(chóng)可以做什么?
                                                                                        你可以用爬蟲(chóng)爬圖片,爬取視頻等等你想要爬取的數據,只要你能通過(guò)瀏覽器訪(fǎng)問(wèn)的數據都可以通過(guò)爬蟲(chóng)獲取。
                                                                                        爬蟲(chóng)的本質(zhì)是什么?
                                                                                        模擬瀏覽器打開(kāi)網(wǎng)頁(yè),獲取網(wǎng)頁(yè)中我們想要的那部分數據
                                                                                        瀏覽器打開(kāi)網(wǎng)頁(yè)的過(guò)程:
                                                                                        當你在瀏覽器中輸入地址后,經(jīng)過(guò)DNS服務(wù)器找到服務(wù)器主機,向服務(wù)器發(fā)送一個(gè)請求,服務(wù)器經(jīng)過(guò)解析后發(fā)送給用戶(hù)瀏覽器結果,包括html,js,css等文件內容,瀏覽器解析出來(lái)*呈現給用戶(hù)在瀏覽器上看到的結果。
                                                                                        所以用戶(hù)看到的瀏覽器的結果就是由HTML代碼構成的,我們爬蟲(chóng)就是為了獲取這些內容,通過(guò)分析和過(guò)濾html代碼,從中獲取我們想要資源。

                                                                                        如何用Python爬蟲(chóng)抓取網(wǎng)頁(yè)內容?

                                                                                        爬蟲(chóng)流程
                                                                                        其實(shí)把網(wǎng)絡(luò )爬蟲(chóng)抽象開(kāi)來(lái)看,它無(wú)外乎包含如下幾個(gè)步驟
                                                                                        模擬請求網(wǎng)頁(yè)。模擬瀏覽器,打開(kāi)目標網(wǎng)站。
                                                                                        獲取數據。打開(kāi)網(wǎng)站之后,就可以自動(dòng)化的獲取我們所需要的網(wǎng)站數據。
                                                                                        保存數據。拿到數據之后,需要持久化到本地文件或者數據庫等存儲設備中。
                                                                                        那么我們該如何使用 Python 來(lái)編寫(xiě)自己的爬蟲(chóng)程序呢,在這里我要重點(diǎn)介紹一個(gè) Python 庫:Requests。
                                                                                        Requests 使用
                                                                                        Requests 庫是 Python 中發(fā)起 HTTP 請求的庫,使用非常方便簡(jiǎn)單。
                                                                                        模擬發(fā)送 HTTP 請求
                                                                                        發(fā)送 GET 請求
                                                                                        當我們用瀏覽器打開(kāi)豆瓣首頁(yè)時(shí),其實(shí)發(fā)送的最原始的請求就是 GET 請求
                                                                                        import requests
                                                                                        res = requests.get('
                                                                                        print(res)
                                                                                        print(type(res))
                                                                                        >>>

                                                                                        python爬蟲(chóng)入門(mén)教程

                                                                                        很簡(jiǎn)單,三步,用爬蟲(chóng)框架scrapy
                                                                                        1. 定義item類(lèi)
                                                                                        2. 開(kāi)發(fā)spider類(lèi)
                                                                                        3. 開(kāi)發(fā)pipeline
                                                                                        如果有不會(huì )的,可以看一看《瘋狂python講義》

                                                                                        如何用Python做爬蟲(chóng)

                                                                                        1)首先你要明白爬蟲(chóng)怎樣工作。
                                                                                        想象你是一只蜘蛛,現在你被放到了互聯(lián)“網(wǎng)”上。那么,你需要把所有的網(wǎng)頁(yè)都看一遍。怎么辦呢?沒(méi)問(wèn)題呀,你就隨便從某個(gè)地方開(kāi)始,比如說(shuō)人民日報的首頁(yè),這個(gè)叫initial pages,用$表示吧。
                                                                                        在人民日報的首頁(yè),你看到那個(gè)頁(yè)面引向的各種鏈接。于是你很開(kāi)心地從爬到了“國內新聞”那個(gè)頁(yè)面。太好了,這樣你就已經(jīng)爬完了倆頁(yè)面(首頁(yè)和國內新聞)!暫且不用管爬下來(lái)的頁(yè)面怎么處理的,你就想象你把這個(gè)頁(yè)面完完整整抄成了個(gè)html放到了你身上。
                                                                                        突然你發(fā)現, 在國內新聞這個(gè)頁(yè)面上,有一個(gè)鏈接鏈回“首頁(yè)”。作為一只聰明的蜘蛛,你肯定知道你不用爬回去的吧,因為你已經(jīng)看過(guò)了啊。所以,你需要用你的腦子,存下你已經(jīng)看過(guò)的頁(yè)面地址。這樣,每次看到一個(gè)可能需要爬的新鏈接,你就先查查你腦子里是不是已經(jīng)去過(guò)這個(gè)頁(yè)面地址。如果去過(guò),那就別去了。
                                                                                        好的,理論上如果所有的頁(yè)面可以從initial page達到的話(huà),那么可以證明你一定可以爬完所有的網(wǎng)頁(yè)。
                                                                                        那么在python里怎么實(shí)現呢?
                                                                                        很簡(jiǎn)單
                                                                                        import Queue
                                                                                        initial_page = "初始化頁(yè)"
                                                                                        url_queue = Queue.Queue()
                                                                                        seen = set()
                                                                                        seen.insert(initial_page)
                                                                                        url_queue.put(initial_page)
                                                                                        while(True): #一直進(jìn)行直到??菔癄€
                                                                                        if url_queue.size()>0:
                                                                                        current_url = url_queue.get() #拿出隊例中*個(gè)的url
                                                                                        store(current_url) #把這個(gè)url代表的網(wǎng)頁(yè)存儲好
                                                                                        for next_url in extract_urls(current_url): #提取把這個(gè)url里鏈向的url
                                                                                        if next_url not in seen:
                                                                                        seen.put(next_url)
                                                                                        url_queue.put(next_url)
                                                                                        else:
                                                                                        break
                                                                                        寫(xiě)得已經(jīng)很偽代碼了。
                                                                                        所有的爬蟲(chóng)的backbone都在這里,下面分析一下為什么爬蟲(chóng)事實(shí)上是個(gè)非常復雜的東西——搜索引擎公司通常有一整個(gè)團隊來(lái)維護和開(kāi)發(fā)。
                                                                                        2)效率
                                                                                        如果你直接加工一下上面的代碼直接運行的話(huà),你需要一整年才能爬下整個(gè)豆瓣的內容。更別說(shuō)Google這樣的搜索引擎需要爬下全網(wǎng)的內容了。
                                                                                        問(wèn)題出在哪呢?需要爬的網(wǎng)頁(yè)實(shí)在太多太多了,而上面的代碼太慢太慢了。設想全網(wǎng)有N個(gè)網(wǎng)站,那么分析一下判重的復雜度就是N*log(N),因為所有網(wǎng)頁(yè)要遍歷一次,而每次判重用set的話(huà)需要log(N)的復雜度。OK,OK,我知道python的set實(shí)現是hash——不過(guò)這樣還是太慢了,至少內存使用效率不高。
                                                                                        通常的判重做法是怎樣呢?Bloom Filter. 簡(jiǎn)單講它仍然是一種hash的方法,但是它的特點(diǎn)是,它可以使用固定的內存(不隨url的數量而增長(cháng))以O(1)的效率判定url是否已經(jīng)在set中??上煜聸](méi)有白吃的午餐,它的*問(wèn)題在于,如果這個(gè)url不在set中,BF可以*確定這個(gè)url沒(méi)有看過(guò)。但是如果這個(gè)url在set中,它會(huì )告訴你:這個(gè)url應該已經(jīng)出現過(guò),不過(guò)我有2%的不確定性。注意這里的不確定性在你分配的內存足夠大的時(shí)候,可以變得很小很少。一個(gè)簡(jiǎn)單的教程:Bloom Filters by Example
                                                                                        注意到這個(gè)特點(diǎn),url如果被看過(guò),那么可能以小概率重復看一看(沒(méi)關(guān)系,多看看不會(huì )累死)。但是如果沒(méi)被看過(guò),一定會(huì )被看一下(這個(gè)很重要,不然我們就要漏掉一些網(wǎng)頁(yè)了?。?。 [IMPORTANT: 此段有問(wèn)題,請暫時(shí)略過(guò)]
                                                                                        好,現在已經(jīng)接近處理判重最快的方法了。另外一個(gè)瓶頸——你只有一臺機器。不管你的帶寬有多大,只要你的機器下載網(wǎng)頁(yè)的速度是瓶頸的話(huà),那么你只有加快這個(gè)速度。用一臺機子不夠的話(huà)——用很多臺吧!當然,我們假設每臺機子都已經(jīng)進(jìn)了*的效率——使用多線(xiàn)程(python的話(huà),多進(jìn)程吧)。
                                                                                        3)集群化抓取
                                                                                        爬取豆瓣的時(shí)候,我總共用了100多臺機器晝夜不停地運行了一個(gè)月。想象如果只用一臺機子你就得運行100個(gè)月了...
                                                                                        那么,假設你現在有100臺機器可以用,怎么用python實(shí)現一個(gè)分布式的爬取算法呢?
                                                                                        我們把這100臺中的99臺運算能力較小的機器叫作slave,另外一臺較大的機器叫作master,那么回顧上面代碼中的url_queue,如果我們能把這個(gè)queue放到這臺master機器上,所有的slave都可以通過(guò)網(wǎng)絡(luò )跟master聯(lián)通,每當一個(gè)slave完成下載一個(gè)網(wǎng)頁(yè),就向master請求一個(gè)新的網(wǎng)頁(yè)來(lái)抓取。而每次slave新抓到一個(gè)網(wǎng)頁(yè),就把這個(gè)網(wǎng)頁(yè)上所有的鏈接送到master的queue里去。同樣,bloom filter也放到master上,但是現在master只發(fā)送確定沒(méi)有被訪(fǎng)問(wèn)過(guò)的url給slave。Bloom Filter放到master的內存里,而被訪(fǎng)問(wèn)過(guò)的url放到運行在master上的Redis里,這樣保證所有操作都是O(1)。(至少平攤是O(1),Redis的訪(fǎng)問(wèn)效率見(jiàn):LINSERT – Redis)
                                                                                        考慮如何用python實(shí)現:
                                                                                        在各臺slave上裝好scrapy,那么各臺機子就變成了一臺有抓取能力的slave,在master上裝好Redis和rq用作分布式隊列。
                                                                                        代碼于是寫(xiě)成
                                                                                        #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
                                                                                        _queue = ()
                                                                                        bf = ()
                                                                                        initial_pages = "www..com"
                                                                                        while(True):
                                                                                        if request == 'GET':
                                                                                        if _queue.size()>0:
                                                                                        send(_queue.get())
                                                                                        else:
                                                                                        break
                                                                                        elif request == 'POST':
                                                                                        bf.put(request.url)
                                                                                        好的,其實(shí)你能想到,有人已經(jīng)給你寫(xiě)好了你需要的:darkrho/scrapy-redis · GitHub
                                                                                        4)展望及后處理
                                                                                        雖然上面用很多“簡(jiǎn)單”,但是真正要實(shí)現一個(gè)商業(yè)規??捎玫呐老x(chóng)并不是一件容易的事。上面的代碼用來(lái)爬一個(gè)整體的網(wǎng)站幾乎沒(méi)有太大的問(wèn)題。
                                                                                        但是如果附加上你需要這些后續處理,比如
                                                                                        有效地存儲(數據庫應該怎樣安排)
                                                                                        有效地判重(這里指網(wǎng)頁(yè)判重,咱可不想把人民日報和抄襲它的大民日報都爬一遍)
                                                                                        有效地信息抽?。ū热缭趺礃映槿〕鼍W(wǎng)頁(yè)上所有的地址抽取出來(lái),“朝陽(yáng)區奮進(jìn)路*道”),搜索引擎通常不需要存儲所有的信息,比如圖片我存來(lái)干嘛...
                                                                                        及時(shí)更新(預測這個(gè)網(wǎng)頁(yè)多久會(huì )更新一次)
                                                                                        如你所想,這里每一個(gè)點(diǎn)都可以供很多研究者十數年的研究。雖然如此,
                                                                                        “路漫漫其修遠兮,吾將上下而求索”。
                                                                                        所以,不要問(wèn)怎么入門(mén),直接上路就好了:)

                                                                                        python爬蟲(chóng)需要什么基礎

                                                                                        1. 學(xué)習Python基礎知識并實(shí)現基本的爬蟲(chóng)過(guò)程

                                                                                        一般獲取數據的過(guò)程都是按照 發(fā)送請求-獲得頁(yè)面反饋-解析并且存儲數據 這三個(gè)流程來(lái)實(shí)現的。這個(gè)過(guò)程其實(shí)就是模擬了一個(gè)人工瀏覽網(wǎng)頁(yè)的過(guò)程。

                                                                                        Python中爬蟲(chóng)相關(guān)的包很多:urllib、requests、bs4、scrapy、pyspider 等,我們可以按照requests
                                                                                        負責連接網(wǎng)站,返回網(wǎng)頁(yè),Xpath 用于解析網(wǎng)頁(yè),便于抽取數據。

                                                                                        2.了解非結構化數據的存儲

                                                                                        爬蟲(chóng)抓取的數據結構復雜 傳統的結構化數據庫可能并不是特別適合我們使用。我們前期推薦使用MongoDB 就可以。

                                                                                        3. 掌握一些常用的反爬蟲(chóng)技巧

                                                                                        使用代理IP池、抓包、驗證碼的OCR處理等處理方式即可以解決大部分網(wǎng)站的反爬蟲(chóng)策略。

                                                                                        4.了解分布式存儲

                                                                                        分布式這個(gè)東西,聽(tīng)起來(lái)很恐怖,但其實(shí)就是利用多線(xiàn)程的原理讓多個(gè)爬蟲(chóng)同時(shí)工作,需要你掌握 Scrapy + MongoDB + Redis
                                                                                        這三種工具就可以了。

                                                                                        奇米在线7777在线精品|国产成人精品免费视|精品无码不卡一区二区三区|国内综合精品午夜久久资源|亚洲视频在线观看..

                                                                                                                                                                              本文由 全國python學(xué)習中心 整理發(fā)布。更多培訓課程,學(xué)習資訊,課程優(yōu)惠,課程開(kāi)班,學(xué)校地址等學(xué)校信息,可以留下你的聯(lián)系方式,讓課程老師跟你詳細解答:
                                                                                                                                                                              咨詢(xún)電話(huà):400-850-8622