python多線程爬取

1. python 多線程爬取網站數據利用線程池

"""

@author: wangxingchun

多線程（線程池）

下載數據

"""

import requests

import csv

from concurrent.futures import ThreadPoolExecutor as tp

#創建一個csv文件，注意創建writer對象"csv.writer()"

f = open('xinfadi.csv','w',encoding='utf8')

csvwrite = csv.writer(f)

#如果寫入txt文件，不需要創建writer對象。

# f = open('xinfadidata.txt','w',encoding='utf8')

#創建一個函數，以頁碼做為參數

def down(n_page):

url = 'http://www.xinfadi.com.cn/getPriceData.html'

data = {'count': 428225,'current': n_page,'limit': 20}

resp = requests.post(url,data=data)

datas =resp.json()

#通過分析數據嵌套情況，獲取數據。此處可在網頁開發工具json數據中查看分析。

for i in range(len(datas['list'])):

name = datas['list'][i]['prodName']

highPrice = datas['list'][i]['highPrice']

lowPrice = datas['list'][i]['lowPrice']

pubDate = datas['list'][i]['pubDate']

place = datas['list'][i]['place']

csvwrite.writerow((name,highPrice,lowPrice,pubDate,place))#writerow要求寫入的是可迭代對象

# f.writelines(f'{name},{highPrice},{lowPrice},{pubDate},{place} ')

resp.close()

if __name__ == '__main__':

with tp(50) as t: #創建線程池，

for n in range(1,101): #遍歷數據網頁

t.submit(down,n) #提交給線程池，進行多線程下載

print(f'共{n}頁數據下載完畢!')

f.close()

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爬取數據

方法/步驟

• 在做爬取數據之前，你需要下載安裝兩個東西，一個是urllib,另外一個是python-docx。

  

• 7

  這個爬下來的是源代碼，如果還需要篩選的話需要自己去添加各種正則表達式。

4. python之多線程

進程的概念：以一個整體的形式暴露給操作系統管理，裡麵包含各種資源的調用。 對各種資源管理的集合就可以稱為進程。
線程的概念：是操作系統能夠進行運算調度的最小單位。本質上就是一串指令的集合。

進程和線程的區別：
1、線程共享內存空間，進程有獨立的內存空間。
2、線程啟動速度快，進程啟動速度慢。注意：二者的運行速度是無法比較的。
3、線程是執行的指令集，進程是資源的集合
4、兩個子進程之間數據不共享，完全獨立。同一個進程下的線程共享同一份數據。
5、創建新的線程很簡單，創建新的進程需要對他的父進程進行一次克隆。
6、一個線程可以操作（控制）同一進程里的其他線程，但是進程只能操作子進程
7、同一個進程的線程可以直接交流，兩個進程想要通信，必須通過一個中間代理來實現。
8、對於線程的修改，可能會影響到其他線程的行為。但是對於父進程的修改不會影響到子進程。

第一個程序，使用循環來創建線程，但是這個程序中一共有51個線程，我們創建了50個線程，但是還有一個程序本身的線程，是主線程。這51個線程是並行的。注意：這個程序中是主線程啟動了子線程。

相比上個程序，這個程序多了一步計算時間，但是我們觀察結果會發現，程序顯示的執行時間只有0.007秒，這是因為最後一個print函數它存在於主線程，而整個程序主線程和所有子線程是並行的，那麼可想而知，在子線程還沒有執行完畢的時候print函數就已經執行了，總的來說，這個時間只是執行了一個線程也就是主線程所用的時間。

接下來這個程序，吸取了上面這個程序的缺點，創建了一個列表，把所有的線程實例都存進去，然後使用一個for循環依次對線程實例調用join方法，這樣就可以使得主線程等待所創建的所有子線程執行完畢才能往下走。 注意實驗結果：和兩個線程的結果都是兩秒多一點

注意觀察實驗結果，並沒有執行列印task has done，並且程序執行時間極其短。
這是因為在主線程啟動子線程前把子線程設置為守護線程。
只要主線程執行完畢，不管子線程是否執行完畢，就結束。但是會等待非守護線程執行完畢
主線程退出，守護線程全部強制退出。皇帝死了，僕人也跟著殉葬
應用的場景 ： socket-server

注意：gil只是為了減低程序開發復雜度。但是在2.幾的版本上，需要加用戶態的鎖（gil的缺陷）而在3點幾的版本上，加鎖不加鎖都一樣。

下面這個程序是一個典型的生產者消費者模型。
生產者消費者模型是經典的在開發架構中使用的模型
運維中的集群就是生產者消費者模型，生活中很多都是

那麼，多線程的使用場景是什麼？
python中的多線程實質上是對上下文的不斷切換，可以說是假的多線程。而我們知道，io操作不佔用cpu，計算佔用cpu，那麼python的多線程適合io操作密集的任務，比如socket-server，那麼cpu密集型的任務，python怎麼處理？python可以折中的利用計算機的多核：啟動八個進程，每個進程有一個線程。這樣就可以利用多進程解決多核問題。

5. Python爬蟲實戰，Python多線程抓取5千多部最新電影下載鏈接

利用Python多線程爬了5000多部最新電影下載鏈接，廢話不多說~

讓我們愉快地開始吧~

Python版本： 3.6.4

相關模塊：

requests模塊；

re模塊；

csv模塊；

以及一些Python自帶的模塊。

安裝Python並添加到環境變數，pip安裝需要的相關模塊即可。

拿到鏈接之後，接下來就是繼續訪問這些鏈接，然後拿到電影的下載鏈接

但是這里還是有很多的小細節，例如我們需要拿到電影的總頁數，其次這么多的頁面，一個線程不知道要跑到什麼時候，所以我們首先先拿到總頁碼，然後用多線程來進行任務的分配

我們首先先拿到總頁碼，然後用多線程來進行任務的分配

總頁數其實我們用re正則來獲取

爬取的內容存取到csv，也可以寫個函數來存取

開啟4個進程來下載鏈接

您學廢了嗎？最後祝大家天天進步！！學習Python最重要的就是心態。我們在學習過程中必然會遇到很多難題，可能自己想破腦袋都無法解決。這都是正常的，千萬別急著否定自己，懷疑自己。如果大家在剛開始學習中遇到困難，想找一個python學習交流環境，可以加入我們，領取學習資料，一起討論，會節約很多時間，減少很多遇到的難題。

6. python爬蟲如何分析一個將要爬取的網站

首先，你去爬取一個網站，

你會清楚這個網站是屬於什麼類型的網站（新聞，論壇，貼吧等等）。

你會清楚你需要哪部分的數據。

你需要去想需要的數據你將如何編寫表達式去解析。

你會碰到各種反爬措施，無非就是各種網路各種解決。當爬取成本高於數據成本，你會選擇放棄。

你會利用你所學各種語言去解決你將要碰到的問題，利用各種語言的client組件去請求你想要爬取的URL，獲取到HTML，利用正則，XPATH去解析你想要的數據，然後利用sql存儲各類資料庫。

7. python可以多線程爬蟲嗎

當然可以，比如python的爬蟲框架scrapy就提供了多線程的功能，當然你也可以自己寫多線程

8. python3 獲取title的編寫

水平有限，不會造輪子，只為學習。

在原來寫埠掃描的基礎上進一步爬取web服務的title信息，方便收集信息。
適用於在外網收集資產形成IP字典後去批量獲取title，意在最快地尋找脆弱點。
自行安裝BeautifulSoup4、requests庫。
V1.0
python3 寫的單線程爬取web系統的title信息。
註解
1.使用BeautifulSoup4庫來解析HTML，爬取title信息；
2.列印title時，帶有顏色的輸出；
3.在開放443、4433、8443埠時，採用https進行訪問；
4.解決SSL認證問題；

V1.0.1
python3 單線程寫的爬取網站title信息。增加了OptionParser模塊，運行時看起來比較舒服。
註解
1.依然是從IP字典里爬取，實際運行腳本時，即使沒有獲取title，也應該手動訪問開放的埠，往往有意外驚喜；
2.埠內置在腳本里，可自行修改；

V1.1
python3寫的多線程爬取web系統的title。
註解
1.只是使用threading模塊，沒有添加到隊列，也沒有加鎖；本身port_list也不多；

V1.2
python3 寫的多線程加隊列的來爬取web系統的title信息。
註解
1.增加了queue隊列，和多線程配合使用。更加實用；

V1.3
python3 寫的多線程加隊列的來爬取web系統的title信息。
增加result輸出結果到文本，適應於內外網埠掃描並獲取title

python3 編寫掃描IP網段如192.168.1.0/24某些指定應用埠爬取title信息。 在代理進行內網滲透時內網資產不容易找到。
適用於內網、外網環境。
自行安裝BeautifulSoup4、requests庫。
V2.0
python3寫的掃描IP段並爬取title信息，收集資產。
註解
1.使用ipaddress模塊獲取C段地址，也可以是B段；
2.只使用threading模塊，沒有添加隊列queue；

V2.1
python3 寫的多線程掃描IP段爬取title。在一定線程下，代理探測內網資產title的非常使用。
註解
1.port_list列表移動到scan方法里；
2.將IP添加到queue隊列，而不是埠；

V2.2
python3 寫的多線程掃描IP段爬取title。
註解
1.只是增加了result_out方法，將結果輸出到指定文件；

https://github.com/aedoo/WebServiceScanner/blob/master/webservicescanner.py

9. python 怎麼實現多線程的

線程也就是輕量級的進程，多線程允許一次執行多個線程，Python是多線程語言，它有一個多線程包，GIL也就是全局解釋器鎖，以確保一次執行單個線程，一個線程保存GIL並在將其傳遞給下一個線程之前執行一些操作，也就產生了並行執行的錯覺。

10. python如何才能獲取src地址

Copyright © 1999-2020, CSDN.NET, All Rights Reserved

python
打開APP

pergoods
關注
Python多線程爬取網站image的src屬性實例 原創
2017-05-16 11:18:51

pergoods

碼齡6年

關注
# coding=utf-8
'''
Created on 2017年5月16日
@author: chenkai
Python多線程爬取某單無聊圖圖片地址(requests+BeautifulSoup+threading+Queue模塊)
'''

import requests
from bs4 import BeautifulSoup
import threading
import Queue
import time

class Spider_Test(threading.Thread):
def __init__(self,queue):
threading.Thread.__init__(self)
self.__queue = queue
def run(self):
while not self.__queue.empty():
page_url=self.__queue.get() [color=red]#從隊列中取出url[/color]
print page_url
self.spider(page_url)
def spider(self,url):
r=requests.get(url) [color=red]#請求url[/color]
soup=BeautifulSoup(r.content,'lxml') [color=red]#r.content就是響應內容，轉換為lxml的bs對象[/color]
imgs = soup.find_all(name='img',attrs={}) #查找所有的img標簽，並獲取標簽屬性值（為列表類型）
for img in imgs:
if 'onload' in str(img): [color=red]#img屬性集合中包含onload屬性的為動態圖.gif,[/color]
print 'http:'+img['org_src']
else:
print 'http:'+img['src']

def main():
queue=Queue.Queue()
url_start = 'http://jandan.net/pic/page-'
for i in range(293,295):
url = url_start+str(i)+'#comment'
queue.put(url) [color=red]#將循環拼接的url放入隊列中[/color]

threads=[]
thread_count=2 [color=red]#默認線程數（可自動修改）[/color]
for i in range(thread_count):
threads.append(Spider_Test(queue))
for i in threads:
i.start()
for i in threads:
i.join()

if __name__ == '__main__':[color=red] #在.py文件中使用這個條件語句，可以使這個條件語句塊中的命令只在它獨立運行時才執行[/color]
time_start = time.time()
main() [color=red]#調用main方法[/color]
print time.time()-time_start

[color=red]#背景知識[/color]
'''
q = Queue.Queue(maxsize = 10)
Queue.Queue類即是一個隊列的同步實現。隊列長度可為無限或者有限。可通過Queue的構造函數的可選參數maxsize來設定隊列長度。如果maxsize小於1就表示隊列長度無限。
將一個值放入隊列中
q.put(10)
調用隊列對象的put()方法在隊尾插入一個項目。put()有兩個參數，第一個item為必需的，為插入項目的值；第二個block為可選參數，默認為
1。如果隊列當前為空且block為1，put()方法就使調用線程暫停,直到空出一個數據單元。如果block為0，put方法將引發Full異常。
將一個值從隊列中取出
q.get()
調用隊列對象的get()方法從隊頭刪除並返回一個項目。可選參數為block，默認為True。如果隊列為空且block為True，get()就使調用線程暫停，直至有項目可用。如果隊列為空且block為False，隊列將引發Empty異常。

'''

[color=red]如果想要下載圖片需要
import urllib

再替換spider方法即可[/color]

def spider(self,url):
r=requests.get(url)
soup=BeautifulSoup(r.content,'lxml')
imgs = soup.find_all(name='img',attrs={})
urls=[]
for img in imgs:
if 'onload' in str(img):
print 'http:'+img['org_src']
urls.append('http:'+img['org_src'])
else:
print 'http:'+img['src']
url = urls.append('http:'+img['src'])
#下載圖片
k=0
for urlitem in urls:
k+=1
if '.jpg' in urlitem:
urllib.urlretrieve(url=urlitem,filename='F:\image\\'+str(k)+'.jpg')

[color=red]-----------多線程訪問網路實例[/color]
#coding:utf-8
import requests
import threading
import time
import sys

url = 'https://www..com'

def get_():
global url
time_start = time.time()
r = requests.get(url=url)
times = time.time()-time_start
sys.stdout.write('status:%s time:%s current_time:%s\n'%(r.status_code,times,time.strftime('%H:%M:%S')))

def main():
threads = []
thread_count = 10
for i in range(thread_count):
t = threading.Thread(target=get_,args=())
threads.append(t)
for i in range(thread_count):
threads[i].start()

for i in range(thread_count):
threads[i].join()

if __name__=='__main__':