送書｜為避免尬聊，我竟爬取了一千多張斗圖
大家好，我是啃書君。
前幾天和女神聊天的時候?qū)嵲谑翘瘟?，因為沒有足夠的斗圖表情包，整個聊天的氣氛都帶動不起來，所以抑郁不得志！
為了追到心目中的完美女神，我爬了一千多張斗圖表情包，只為下一次聊天的時候，主動權(quán)都在我的手上。
考慮到有些小伙伴可能在python基礎(chǔ)不是很好，因此，啃書君決定先幫各位補(bǔ)補(bǔ)基礎(chǔ)知識，大佬可以直接看實戰(zhàn)內(nèi)容。本次實戰(zhàn)內(nèi)容是爬取：斗圖吧。
面向?qū)ο?/span>
python從設(shè)計開始就是一門面向?qū)ο蟮牡恼Z言，因此使用python創(chuàng)建一個類與對象是非常簡單的一件事情。
如果你以前沒有接觸過面向?qū)ο蟮木幊陶Z言，那么你需要了解一些面向?qū)ο笳Z言的一些基本特征，接下來就來感受python的面向?qū)ο笳Z言。
面向?qū)ο蠛喗?/span>
-
類(Class)：用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的實例。 -
類變量：類變量在整個實例化的對象中是公共的。類變量定義在類中，且在函數(shù)體外。 -
數(shù)據(jù)成員：類變量或?qū)嵗兞?，用于處理類及其實例對象的相關(guān)數(shù)據(jù)。 -
方法重載：如果從父類繼承的方法，無法滿足子類的需求，可以對其進(jìn)行改寫，這個過程叫做覆蓋，也稱為方法的重載。 -
實例變量：定義在方法中的變量，只作用于當(dāng)前實例的類。 -
繼承：即一個派生類，繼承基類（父類）的字段與方法。 -
實例化：創(chuàng)建一個實例，類的具體對象。 -
方法：類中定義的函數(shù) -
對象：通過類定義的數(shù)據(jù)結(jié)構(gòu)實例。對象包括兩個數(shù)據(jù)成員（類變量和實例變量）和方法。
創(chuàng)建類與對象
類相當(dāng)于一個模板，模板里面可以有多個函數(shù)，函數(shù)用于實現(xiàn)功能。
對象其實是根據(jù)模板創(chuàng)建的一個實例，通過創(chuàng)建的實例可以執(zhí)行類中的函數(shù)。
# 創(chuàng)建類
class Foo(object):
# 創(chuàng)建類中的函數(shù)
def bar(self):
# todo
pass
# 根據(jù)Foo類創(chuàng)建對象obj
obj = Foo()
-
class是關(guān)鍵字，代表類 -
object代碼父類，所有類都繼承object類 -
創(chuàng)建對象，類名稱后加上括號即可
面向?qū)ο蟮娜筇匦?/span>
封裝
封裝，顧名思義就是將內(nèi)容封裝到某個地方，以后再去調(diào)用被封裝在某處的內(nèi)容。
所以，在使用面向?qū)ο蟮姆庋b特性時，需要：
-
將內(nèi)容封裝到某處 -
從某處調(diào)用被封裝的內(nèi)容
class Foo(object):
# 構(gòu)造方法，根據(jù)類創(chuàng)建對象時自動執(zhí)行
def __init__(self, name, age):
self.name = name
self.age = age
# 根據(jù)類Foo創(chuàng)建對象
# 自動啟動Foo類的__init__方法
obj1 = Foo('Jack', 18)
obj2 = Fo('Rose', 20)
obj1 = Foo('Jack', 18) 將Jack和18分別封裝到obj1(self)的name和age屬性中，obj2也是同樣的道理。
self是一個形式參數(shù)，當(dāng)執(zhí)行obj1 = Foo('Jack', 18) ，self等于obj1，因此，每個對象都有name和age屬性。
通過對象調(diào)用封裝內(nèi)容
class Foo(object):
def __init__(self, name, age):
self.name = name
self.age = age
obj1 = Foo('Jack', 18)
print(obj1.name) # 調(diào)用obj1的name屬性
print(obj1.age) # 調(diào)用obj1的age屬性
obj2 = Foo('Jack', 18)
print(obj2.name) # 調(diào)用obj2的name屬性
print(obj2.age) # 調(diào)用obj2的age屬性
通過self間接調(diào)用封裝的內(nèi)容
class Foo(object):
def __init__(self, name, age):
self.name = name
self.age = age
def detail(self):
print(self.name)
print(self.age)
obj1 = Foo('Jack', 18)
obj1.detail()
obj2 = Foo('Rose', 20)
obj2.detail()
obj1.detail() python默認(rèn)會將obj1傳給self參數(shù)，即：obj1.detail(obj1)，所以，此時方法內(nèi)部的self=obj1，即self.name相當(dāng)于obj1.name。
感受面向?qū)ο蟮暮啽?/span>
對于面向?qū)ο蠓庋b來說，其實就是使用構(gòu)造方法將內(nèi)容封裝到對象中，然后通過對象直接或者self間接獲取封裝內(nèi)容。
接下來，我們就來體驗一下面向?qū)ο蟮暮啽阈浴?/p>
def kanchai(name, age, gender):
print "%s,%s歲,%s,上山去砍柴" %(name, age, gender)
def qudongbei(name, age, gender):
print "%s,%s歲,%s,開車去東北" %(name, age, gender)
def dabaojian(name, age, gender):
print "%s,%s歲,%s,最愛大保健" %(name, age, gender)
kanchai('小明', 10, '男')
qudongbei('小明', 10, '男')
dabaojian('小明', 10, '男')
kanchai('老李', 90, '男')
qudongbei('老李', 90, '男')
dabaojian('老李', 90, '男')
函數(shù)式編程
class Foo(object):
def __init__(self, name, age ,gender):
self.name = name
self.age = age
self.gender = gender
def kanchai(self):
print "%s,%s歲,%s,上山去砍柴" %(self.name, self.age, self.gender)
def qudongbei(self):
print "%s,%s歲,%s,開車去東北" %(self.name, self.age, self.gender)
def dabaojian(self):
print "%s,%s歲,%s,最愛大保健" %(self.name, self.age, self.gender)
xiaoming = Foo('小明', 10, '男')
xiaoming.kanchai()
xiaoming.qudongbei()
xiaoming.dabaojian()
laoli = Foo('老李', 90, '男')
laoli.kanchai()
laoli.qudongbei()
laoli.dabaojian()
如果使用函數(shù)式編程，需要在每一個執(zhí)行函數(shù)的時候都要傳入相同的參數(shù)，如果參數(shù)多的話，就每一次都要復(fù)制粘貼，非常不方便；而對于面向?qū)ο髞碚f，只需要在創(chuàng)建對象時，將所需要的參數(shù)封裝到對象中，然后通過對象調(diào)用即可獲取封裝的內(nèi)容。
繼承
繼承就是讓類和類之間存在父子關(guān)系，子類可以直接訪問父類的靜態(tài)屬性與方法。在python中，新建的類可以繼承一個或多個父類，父類可以稱為基類或超類，新建的類稱為派生類或子類。
class ParentClass1: #定義父類1
pass
class ParentClass2: #定義父類2
pass
class SubClass1(ParentClass1):
# 單繼承，基類是ParentClass1，派生類是SubClass
pass
class SubClass2(ParentClass1,ParentClass2):
# python支持多繼承，用逗號分隔開多個繼承的類
pass
print(SubClass1.__bases__) # 查看所有繼承的父類
print(SubClass2.__bases__)
# ===============
# (<class '__main__.Father1'>,)
# (<class '__main__.Father1'>, <class '__main__.Father2'>)
繼承的規(guī)則
1、子類繼承父類的成員變量與方法
2、子類不繼承父類的構(gòu)造方法
3、子類不能刪除父類成員，但是可以重新定義父類成員
4、子類可以增加自己的成員。
具體代碼，如下所示：
class Person(object):
def __init__(self, name, age, sex):
self.name = 'jasn'
self.age = 18
self.sex = sex
def talk(self):
print('I want to say someting to you')
class Chinese(Person):
def __init__(self, name, age, sex, language):
Person.__init__(self, name, age, sex) # 用父類的name, age, sex覆蓋掉子類的屬性
self.age = age # 覆蓋掉父類的age屬性，取值為子類實例傳入的age參數(shù)
self.language = 'Chinese'
def talk(self):
print('我說的是普通話')
Person.talk(self)
obj = Chinese('nancy', 30, 'male', '普通話')
print(obj.name)
print(obj.age)
print(obj.language)
obj.talk()
運(yùn)行結(jié)果，如下：
jasn
30
Chinese
我說的是普通話
I want to say someting to you
因為，Chinese類覆蓋了Person類，在開始的時候，我們將父類的屬性覆蓋了子類的屬性，比如說name屬性，子類沒有去覆蓋父類，因此，即使子類傳來了name屬性值，但依舊還是輸出父類的name屬性。
繼承的作用
1、實現(xiàn)代碼（功能）重用，降低代碼冗余
2、增強(qiáng)軟件的可擴(kuò)充性
3、提高軟件的維護(hù)性
繼承與抽象的概念
面向?qū)ο蟮膬蓚€重要概念：抽象與分類。
class animal(): # 定義父類
country = 'china' # 這個叫類的變量
def __init__(self,name,age):
self.name = name # 這些又叫數(shù)據(jù)屬性
self.age = age
def walk(self): # 類的函數(shù)，方法，動態(tài)屬性
print('%s is walking'%self.name)
def say(self):
pass
class people(animal): # 子類繼承父類
pass
class pig(animal): # 子類繼承父類
pass
class dog(animal): # 子類繼承父類
pass
aobama=people('aobama',60) # 實例化一個對象
print(aobama.name)
aobama.walk()
上面的代碼可以這樣理解：我們將人、狗、豬抽象為動物，人、狗、豬都繼承動物類。
python中super()的作用和原理
super()在類的繼承里面非常常用，它解決了子類調(diào)用父類方法的一些問題。下面我們來看一下，它優(yōu)化了什么問題。
class Foo(object):
def bar(self, message):
print(message)
obj1 = Foo()
obj1.bar('hello')
當(dāng)存在繼承關(guān)系的時候，有時候需要在子類中調(diào)用父類方法，此時最簡單的方法就是把對象調(diào)用轉(zhuǎn)換成類調(diào)用，需要注意的是這時self參數(shù)需要顯示傳遞。
具體代碼，如下所示：
class FooParent(object):
"""docstring for FooParent"""
def bar(self, message):
print(message)
class FooChild(FooParent):
"""docstring for FooChild"""
def bar(self, message):
FooParent.bar(self, message)
foochild = FooChild()
foochild.bar('hello')
這樣的繼承方式其實是存在缺陷的，比如說，我修改了父類的名稱，那么子類中將要涉及多處修改。
因此python就引入了super()機(jī)制，具體代碼如下所示：
class FooParent(object):
def bar(self, message):
print(message)
class FooChild(FooParent):
def bar(self, message):
super(FooChild, self).bar(message)
obj = FooChild()
obj.bar('hello')
多態(tài)
關(guān)于python多態(tài)的知識，因本次實戰(zhàn)內(nèi)容中并沒有使用到，因此我就不再敘述了，小伙伴們可以自行查找資料去了解。
什么是生產(chǎn)者與消費(fèi)者模式
比如有兩個進(jìn)程A與B，它們共享一個固定大小的緩沖區(qū)，A進(jìn)程生產(chǎn)數(shù)據(jù)放入緩沖區(qū)；B進(jìn)程從緩沖區(qū)取出數(shù)據(jù)進(jìn)行計算，那么這里的A進(jìn)程就相當(dāng)于生產(chǎn)者，B進(jìn)程相當(dāng)于消費(fèi)者。
為什么要使用生產(chǎn)者與消費(fèi)者模式
在進(jìn)程的世界里，生產(chǎn)者就是生產(chǎn)數(shù)據(jù)的進(jìn)程，消費(fèi)者就是使用（處理）數(shù)據(jù)的進(jìn)程。同樣的道理，如果消費(fèi)者的處理能力大于生產(chǎn)者，那么消費(fèi)者就必須等待生產(chǎn)者。同樣的道理，如果生產(chǎn)者的處理能力大于消費(fèi)者能力，那么生產(chǎn)者就必須等待消費(fèi)者。
實現(xiàn)了生產(chǎn)者與消費(fèi)者的解耦和，平衡了生產(chǎn)力與消費(fèi)力，因為二者不能直接溝通，而是通過隊列進(jìn)行溝通。
生產(chǎn)者消費(fèi)者模式
生產(chǎn)者消費(fèi)者模式是通過一個容器來解決生產(chǎn)者和消費(fèi)者的強(qiáng)耦合問題。
生產(chǎn)者與消費(fèi)者不直接通信，而是通過阻塞隊列進(jìn)行通信，因此，生產(chǎn)者生產(chǎn)完數(shù)據(jù)之后不用等待消費(fèi)者處理，直接扔給阻塞隊列，消費(fèi)者不找生產(chǎn)者要數(shù)據(jù)，而是去阻塞隊列中找數(shù)據(jù)。阻塞隊列就類似于緩沖區(qū)，平衡了生產(chǎn)者與消費(fèi)者的能力。
multiprocess-Queue實現(xiàn)
具體代碼，如下所示：
from multiprocessing import Process, Queue
import time, random
from threading import Thread
import queue
# 生產(chǎn)者
def producer(name, food, q):
for i in range(4):
time.sleep(random.randint(1, 3)) # 模擬產(chǎn)生數(shù)據(jù)的時間
f = '%s 生產(chǎn)了 %s %s個' % (name, food, i + 1)
print(f)
q.put(f)
# 消費(fèi)者
def consumer(name, q):
while True:
food = q.get()
if food is None:
print('%s 獲取到一個空' % name)
break
f = '%s 消費(fèi)了 %s' % (name, food)
print(f)
time.sleep(random.randint(1, 3))
if __name__ == '__main__':
q = Queue() # 創(chuàng)建隊列
# 模擬生產(chǎn)者，產(chǎn)生數(shù)據(jù)
p1 = Process(target=producer, args=('p1', '包子', q))
p1.start()
p2 = Process(target=producer, args=('p2', '燒餅', q))
p2.start()
c1 = Process(target=consumer, args=('c1', q))
c1.start()
c2 = Process(target=consumer, args=('c2', q))
c2.start()
p1.join()
p2.join()
q.put(None)
q.put(None)
Thread-Queue實現(xiàn)
上面的代碼是由多進(jìn)程實現(xiàn)的，接下來就考慮一下多線程實現(xiàn)該功能。
具體代碼，如下所示：
import random
import time
from threading import Thread
import queue
def producer(name, count, q):
for i in range(count):
food = f'{name} 生產(chǎn)第{i}個包子'
print(food)
q.put(food)
def consumer(name, q):
while True:
time.sleep(random.randint(1, 3))
if q.empty():
break
print(f'{name} 消費(fèi)了 {q.get()}')
if __name__ == '__main__':
q = queue.Queue()
print(q.empty())
for i in range(1, 4):
p = Thread(target=producer, args=(f'生產(chǎn)者{i}', 10, q))
p.start()
for i in range(1, 6):
c = Thread(target=consumer, args=(f'消費(fèi)者{i}', q))
c.start()
生產(chǎn)者消費(fèi)者模式特點(diǎn)
-
保證生產(chǎn)者不會在緩沖區(qū)滿的時候繼續(xù)向緩沖區(qū)放入數(shù)據(jù)，而消費(fèi)者也不會在緩沖區(qū)空的時候，消耗數(shù)據(jù)。
-
當(dāng)緩沖區(qū)滿的時候，生產(chǎn)者會進(jìn)入休眠狀態(tài)，當(dāng)下次消費(fèi)者開始消耗緩沖區(qū)數(shù)據(jù)時，生產(chǎn)者才會被喚醒，開始往緩沖區(qū)添加數(shù)據(jù)；當(dāng)緩沖區(qū)空的時候，消費(fèi)者會進(jìn)入休眠狀態(tài)，直到生產(chǎn)者往緩沖區(qū)添加數(shù)據(jù)時才會被喚醒。
基礎(chǔ)知識總結(jié)
到這里，我基本上就將本次實戰(zhàn)需要用到的基礎(chǔ)知識都教給大家了，相當(dāng)于拋磚引玉。拋出我這塊磚，引出小伙伴們的玉。本次的基礎(chǔ)知識主要分為兩大模塊，第一個是面向?qū)ο蟮闹R，第二個則是線程相關(guān)的知識，小伙伴們需要盡可能去熟悉，才能寫出更加高效健壯的爬蟲demo。
實戰(zhàn)篇
工具庫使用
本次爬蟲所需要的工具庫我先列舉出來
import requests
from lxml import etree
import threading
from queue import Queue
import re
缺少哪些就自行安裝。
抓取目標(biāo)
本次實戰(zhàn)所要抓取的網(wǎng)站是斗圖吧。網(wǎng)址如下：
https://www.doutub.com/
我們需要抓取的內(nèi)容是該網(wǎng)站下的斗圖表情包。
瞬間讓你成為斗圖高手。啥也別說了，干就完事。
網(wǎng)頁分析
定睛一看，好家伙，居然有26頁的表情包，這不起飛？
首先來分析一下不同頁面url的地址變化。
# 第一頁
https://www.doutub.com/img_lists/new/1
# 第二頁
https://www.doutub.com/img_lists/new/2
# 第三頁
https://www.doutub.com/img_lists/new/3
看到這種變化的方式之后難道你不先竊喜一下。
頁面url地址已經(jīng)搞定，那接下來要弄清楚的就是每一張表情包的url地址了。
這不是很容易就被聰明的你發(fā)現(xiàn)了嗎？這些鏈接我們采用xpath將其提取出來即可。
生產(chǎn)者的實現(xiàn)
首先，我們先創(chuàng)建兩個隊列，一個用于存儲每一頁的url地址，另一個便用于存儲圖片鏈接。
具體代碼，如下所示：
# 建立隊列
page_queue = Queue() # 頁面url
img_queue = Queue() # 圖片url
for page in range(1, 27):
url = f'https://www.doutub.com/img_lists/new/{page}'
page_queue.put(url)
通過上面的代碼，便將每一頁的url地址放入了page_queue。
接下來再通過創(chuàng)建一個類，將圖片url放入img_queue中。
具體代碼如下所示：
class ImageParse(threading.Thread):
def __init__(self, page_queue, img_queue):
super(ImageParse, self).__init__()
self.page_queue = page_queue
self.img_queue = img_queue
self.headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.77 Safari/537.36'
}
def run(self):
while True:
if self.page_queue.empty():
break
url = self.page_queue.get()
self.parse_img(url)
def parse_img(self, url):
response = requests.get(url, headers=self.headers).content.decode('utf-8')
html = etree.HTML(response)
img_lists = html.xpath('//div[@class="expression-list clearfix"]')
for img_list in img_lists:
img_urls = img_list.xpath('./div/a/img/@src')
img_names = img_list.xpath('./div/a/span/text()')
for img_url, img_name in zip(img_urls, img_names):
self.img_queue.put((img_url, img_name))
消費(fèi)者的實現(xiàn)
其實消費(fèi)者很簡單，我們只需要不斷的從img_page中獲取到圖片的url鏈接并不停的進(jìn)行訪問即可。直到兩個隊列中有一個隊列為空即可退出。
class DownLoad(threading.Thread):
def __init__(self, page_queue, img_queue):
super(DownLoad, self).__init__()
self.page_queue = page_queue
self.img_queue = img_queue
self.headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.77 Safari/537.36'
}
def run(self):
while True:
if self.page_queue.empty() and self.img_queue.empty():
break
img_url, filename = self.img_queue.get()
fix = img_url.split('.')[-1]
name = re.sub(r'[?？.，。！!*\\/|]', '', filename)
# print(fix)
data = requests.get(img_url, headers=self.headers).content
print('正在下載' + filename)
with open('../image/' + name + '.' + fix, 'wb') as f:
f.write(data)
最后，再讓創(chuàng)建好的兩個線程跑起來
for x in range(5):
t1 = ImageParse(page_queue, img_queue)
t1.start()
t2 = DownLoad(page_queue, img_queue)
t2.start()
t1.join()
t2.join()
最后結(jié)果
一共抓取了1269張圖片。
從今往后誰還能比得上你？就這？這不有爬蟲就行！
送書
又到了每周三的送書時刻，今天給大家?guī)淼氖恰?span style="font-family: Arial, "microsoft yahei";font-size: 16px;font-weight: 700;letter-spacing: 0.544px;text-align: start;background-color: rgb(255, 255, 255);">Python量化金融編程從入門到精通》，本書先從量化交易的基本概念講起，然后講解Python的基本語法及常見庫的使用，在每章節(jié)的學(xué)習(xí)中都以金融量化為實例，并在后結(jié)合實戰(zhàn)項目來進(jìn)行學(xué)習(xí)和鞏固，讀者不但可以系統(tǒng)地學(xué)習(xí)Python編程的相關(guān)知識，而且還能學(xué)習(xí)到Python在量化交易場景下的應(yīng)用。
本書內(nèi)容通俗易懂，案例豐富，適合零基礎(chǔ)并對Python量化感興趣的讀者，以及想學(xué)習(xí)量化交易實戰(zhàn)項目的Python初學(xué)者。此外，本書也適合作為相關(guān)培訓(xùn)機(jī)構(gòu)的培訓(xùn)教材。
點(diǎn)擊下方回復(fù)：送書 即可！