scrapy爬取新浪微博+cookie池

前面講解了Scrapy中各個模塊基本使用方法以及代理池、Cookies池。接下來我們以一個反爬比較強的網站新浪微博爲例，來實現一下Scrapy的大規模爬取。

一、本節目標

本次爬取的目標是新浪微博用戶的公開基本信息，如用戶暱稱、頭像、用戶的關注、粉絲列表以及發佈的微博等，這些信息抓取之後保存至MongoDB。

二、準備工作

請確保前文所講的代理池、Cookies池已經實現並可以正常運行，安裝Scrapy、PyMongo庫。

三、爬取思路

首先我們要實現用戶的大規模爬取。這裏採用的爬取方式是，以微博的幾個大V爲起始點，爬取他們各自的粉絲和關注列表，然後獲取粉絲和關注列表的粉絲和關注列表，以此類推，這樣下去就可以實現遞歸爬取。如果一個用戶與其他用戶有社交網絡上的關聯，那他們的信息就會被爬蟲抓取到，這樣我們就可以做到對所有用戶的爬取。通過這種方式，我們可以得到用戶的唯一ID，再根據ID獲取每個用戶發佈的微博即可。

四、爬取分析

這裏我們選取的爬取站點是：https://m.weibo.cn，此站點是微博移動端的站點。打開該站點會跳轉到登錄頁面，這是因爲主頁做了登錄限制。不過我們可以繞過登錄限制，直接打開某個用戶詳情頁面，例如打開周冬雨的微博，鏈接爲：https://m.weibo.cn/u/1916655407，即可進入其個人詳情頁面，如下圖所示。

我們在頁面最上方可以看到周冬雨的關注和粉絲數量。我們點擊關注，進入到她的關注列表，如下圖所示。

我們打開開發者工具，切換到XHR過濾器，一直下拉關注列表，即可看到下方會出現很多Ajax請求，這些請求就是獲取周冬雨的關注列表的Ajax請求，如下圖所示。

我們打開第一個Ajax請求，它的鏈接爲：https://m.weibo.cn/api/container/getIndex?containerid=231051-_followers-_1916655407&luicode=10000011&lfid=1005051916655407&featurecode=20000320&type=uid&value=1916655407&page=2，詳情如下圖所示。

請求類型是GET類型，返回結果是JSON格式，我們將其展開之後即可看到其關注的用戶的基本信息。接下來我們只需要構造這個請求的參數。此鏈接一共有7個參數，如下圖所示。

其中最主要的參數就是containerid和page。有了這兩個參數，我們同樣可以獲取請求結果。我們可以將接口精簡爲：https://m.weibo.cn/api/container/getIndex?containerid=231051-_followers-_1916655407&page=2，這裏的container_id的前半部分是固定的，後半部分是用戶的id。所以這裏參數就可以構造出來了，只需要修改container_id最後的id和page參數即可獲取分頁形式的關注列表信息。

利用同樣的方法，我們也可以分析用戶詳情的Ajax鏈接、用戶微博列表的Ajax鏈接，如下所示：

# 用戶詳情API
user_url = 'https://m.weibo.cn/api/container/getIndex?uid={uid}&type=uid&value={uid}&containerid=100505{uid}'
# 關注列表API
follow_url = 'https://m.weibo.cn/api/container/getIndex?containerid=231051_-_followers_-_{uid}&page={page}'
# 粉絲列表API
fan_url = 'https://m.weibo.cn/api/container/getIndex?containerid=231051_-_fans_-_{uid}&page={page}'
# 微博列表API
weibo_url = 'https://m.weibo.cn/api/container/getIndex?uid={uid}&type=uid&page={page}&containerid=107603{uid}'

此處的uid和page分別代表用戶ID和分頁頁碼。

注意，這個API可能隨着時間的變化或者微博的改版而變化，以實測爲準。

我們從幾個大V開始抓取，抓取他們的粉絲、關注列表、微博信息，然後遞歸抓取他們的粉絲和關注列表的粉絲、關注列表、微博信息，遞歸抓取，最後保存微博用戶的基本信息、關注和粉絲列表、發佈的微博。

我們選擇MongoDB作存儲的數據庫，可以更方便地存儲用戶的粉絲和關注列表。

五、新建項目

接下來我們用Scrapy來實現這個抓取過程。首先創建一個項目，命令如下所示：

scrapy startproject weibo

進入項目中，新建一個Spider，名爲weibocn，命令如下所示：

scrapy genspider weibocn m.weibo.cn

我們首先修改Spider，配置各個Ajax的URL，選取幾個大V，將他們的ID賦值成一個列表，實現start_requests()方法，也就是依次抓取各個大V的個人詳情，然後用parse_user()進行解析，如下所示：

from scrapy import Request, Spider

class WeiboSpider(Spider):
    name = 'weibocn'
    allowed_domains = ['m.weibo.cn']
    user_url = 'https://m.weibo.cn/api/container/getIndex?uid={uid}&type=uid&value={uid}&containerid=100505{uid}'
    follow_url = 'https://m.weibo.cn/api/container/getIndex?containerid=231051_-_followers_-_{uid}&page={page}'
    fan_url = 'https://m.weibo.cn/api/container/getIndex?containerid=231051_-_fans_-_{uid}&page={page}'
    weibo_url = 'https://m.weibo.cn/api/container/getIndex?uid={uid}&type=uid&page={page}&containerid=107603{uid}'
    start_users = ['3217179555', '1742566624', '2282991915', '1288739185', '3952070245', '5878659096']

    def start_requests(self):
        for uid in self.start_users:
            yield Request(self.user_url.format(uid=uid), callback=self.parse_user)

    def parse_user(self, response):
        self.logger.debug(response)

六、創建Item

接下來我們解析用戶的基本信息並生成Item。這裏我們先定義幾個Item，如用戶、用戶關係、微博的Item，如下所示：

from scrapy import Item, Field

class UserItem(Item):
    collection = 'users'
    id = Field()
    name = Field()
    avatar = Field()
    cover = Field()
    gender = Field()
    description = Field()
    fans_count = Field()
    follows_count = Field()
    weibos_count = Field()
    verified = Field()
    verified_reason = Field()
    verified_type = Field()
    follows = Field()
    fans = Field()
    crawled_at = Field()

class UserRelationItem(Item):
    collection = 'users'
    id = Field()
    follows = Field()
    fans = Field()

class WeiboItem(Item):
    collection = 'weibos'
    id = Field()
    attitudes_count = Field()
    comments_count = Field()
    reposts_count = Field()
    picture = Field()
    pictures = Field()
    source = Field()
    text = Field()
    raw_text = Field()
    thumbnail = Field()
    user = Field()
    created_at = Field()
    crawled_at = Field()

這裏定義了collection字段，指明保存的Collection的名稱。用戶的關注和粉絲列表直接定義爲一個單獨的UserRelationItem，其中id就是用戶的ID，follows就是用戶關注列表，fans是粉絲列表，但這並不意味着我們會將關注和粉絲列表存到一個單獨的Collection裏。後面我們會用Pipeline對各個Item進行處理、合併存儲到用戶的Collection裏，因此Item和Collection並不一定是完全對應的。

七、提取數據

我們開始解析用戶的基本信息，實現parse_user()方法，如下所示：

def parse_user(self, response):
    """
    解析用戶信息
    :param response: Response對象
    """
    result = json.loads(response.text)
    if result.get('data').get('userInfo'):
        user_info = result.get('data').get('userInfo')
        user_item = UserItem()
        field_map = {
            'id': 'id', 'name': 'screen_name', 'avatar': 'profile_image_url', 'cover': 'cover_image_phone',
            'gender': 'gender', 'description': 'description', 'fans_count': 'followers_count',
            'follows_count': 'follow_count', 'weibos_count': 'statuses_count', 'verified': 'verified',
            'verified_reason': 'verified_reason', 'verified_type': 'verified_type'
        }
        for field, attr in field_map.items():
            user_item[field] = user_info.get(attr)
        yield user_item
        # 關注
        uid = user_info.get('id')
        yield Request(self.follow_url.format(uid=uid, page=1), callback=self.parse_follows,
                      meta={'page': 1, 'uid': uid})
        # 粉絲
        yield Request(self.fan_url.format(uid=uid, page=1), callback=self.parse_fans,
                      meta={'page': 1, 'uid': uid})
        # 微博
        yield Request(self.weibo_url.format(uid=uid, page=1), callback=self.parse_weibos,
                      meta={'page': 1, 'uid': uid})

在這裏我們一共完成了兩個操作。

解析JSON提取用戶信息並生成UserItem返回。我們並沒有採用常規的逐個賦值的方法，而是定義了一個字段映射關係。我們定義的字段名稱可能和JSON中用戶的字段名稱不同，所以在這裏定義成一個字典，然後遍歷字典的每個字段實現逐個字段的賦值。
構造用戶的關注、粉絲、微博的第一頁的鏈接，並生成Request，這裏需要的參數只有用戶的ID。另外，初始分頁頁碼直接設置爲1即可。

接下來，我們還需要保存用戶的關注和粉絲列表。以關注列表爲例，其解析方法爲parse_follows()，實現如下所示：

def parse_follows(self, response):
    """
    解析用戶關注
    :param response: Response對象
    """
    result = json.loads(response.text)
    if result.get('ok') and result.get('data').get('cards') and len(result.get('data').get('cards')) and result.get('data').get('cards')[-1].get(
        'card_group'):
        # 解析用戶
        follows = result.get('data').get('cards')[-1].get('card_group')
        for follow in follows:
            if follow.get('user'):
                uid = follow.get('user').get('id')
                yield Request(self.user_url.format(uid=uid), callback=self.parse_user)
        # 關注列表
        uid = response.meta.get('uid')
        user_relation_item = UserRelationItem()
        follows = [{'id': follow.get('user').get('id'), 'name': follow.get('user').get('screen_name')} for follow in
                   follows]
        user_relation_item['id'] = uid
        user_relation_item['follows'] = follows
        user_relation_item['fans'] = []
        yield user_relation_item
        # 下一頁關注
        page = response.meta.get('page') + 1
        yield Request(self.follow_url.format(uid=uid, page=page),
                      callback=self.parse_follows, meta={'page': page, 'uid': uid})

那麼在這個方法裏面我們做了如下三件事。

解析關注列表中的每個用戶信息併發起新的解析請求。我們首先解析關注列表的信息，得到用戶的ID，然後再利用user_url構造訪問用戶詳情的Request，回調就是剛纔所定義的parse_user()方法。
提取用戶關注列表內的關鍵信息並生成UserRelationItem。id字段直接設置成用戶的ID，JSON返回數據中的用戶信息有很多冗餘字段。在這裏我們只提取了關注用戶的ID和用戶名，然後把它們賦值給follows字段，fans字段設置成空列表。這樣我們就建立了一個存有用戶ID和用戶部分關注列表的UserRelationItem，之後合併且保存具有同一個ID的UserRelationItem的關注和粉絲列表。
提取下一頁關注。只需要將此請求的分頁頁碼加1即可。分頁頁碼通過Request的meta屬性進行傳遞，Response的meta來接收。這樣我們構造並返回下一頁的關注列表的Request。

抓取粉絲列表的原理和抓取關注列表原理相同，在此不再贅述。

接下來我們還差一個方法的實現，即parse_weibos()，它用來抓取用戶的微博信息，實現如下所示：

def parse_weibos(self, response):
    """
    解析微博列表
    :param response: Response對象
    """
    result = json.loads(response.text)
    if result.get('ok') and result.get('data').get('cards'):
        weibos = result.get('data').get('cards')
        for weibo in weibos:
            mblog = weibo.get('mblog')
            if mblog:
                weibo_item = WeiboItem()
                field_map = {
                    'id': 'id', 'attitudes_count': 'attitudes_count', 'comments_count': 'comments_count', 'created_at': 'created_at',
                    'reposts_count': 'reposts_count', 'picture': 'original_pic', 'pictures': 'pics',
                    'source': 'source', 'text': 'text', 'raw_text': 'raw_text', 'thumbnail': 'thumbnail_pic'
                }
                for field, attr in field_map.items():
                    weibo_item[field] = mblog.get(attr)
                weibo_item['user'] = response.meta.get('uid')
                yield weibo_item
        # 下一頁微博
        uid = response.meta.get('uid')
        page = response.meta.get('page') + 1
        yield Request(self.weibo_url.format(uid=uid, page=page), callback=self.parse_weibos,
                      meta={'uid': uid, 'page': page})

在這裏parse_weibos()方法完成了兩件事。

提取用戶的微博信息，並生成WeiboItem。這裏同樣建立了一個字段映射表，實現批量字段賦值。
提取下一頁的微博列表。這裏同樣需要傳入用戶ID和分頁頁碼。

目前爲止，微博的Spider已經完成。後面還需要對數據進行數據清洗存儲，以及對接代理池、Cookies池來防止反爬蟲。

八、數據清洗

有些微博的時間可能不是標準的時間，比如它可能顯示爲剛剛、幾分鐘前、幾小時前、昨天等。這裏我們需要統一轉化這些時間，實現一個parse_time()方法，如下所示：

def parse_time(self, date):
    if re.match('剛剛', date):
        date = time.strftime('%Y-%m-%d %H:%M', time.localtime(time.time()))
    if re.match('\d+分鐘前', date):
        minute = re.match('(\d+)', date).group(1)
        date = time.strftime('%Y-%m-%d %H:%M', time.localtime(time.time() - float(minute) * 60))
    if re.match('\d+小時前', date):
        hour = re.match('(\d+)', date).group(1)
        date = time.strftime('%Y-%m-%d %H:%M', time.localtime(time.time() - float(hour) * 60 * 60))
    if re.match('昨天.*', date):
        date = re.match('昨天(.*)', date).group(1).strip()
        date = time.strftime('%Y-%m-%d', time.localtime() - 24 * 60 * 60) + ' ' + date
    if re.match('\d{2}-\d{2}', date):
        date = time.strftime('%Y-', time.localtime()) + date + ' 00:00'
    return date

我們用正則來提取一些關鍵數字，用time庫來實現標準時間的轉換。

以X分鐘前的處理爲例，爬取的時間會賦值爲created_at字段。我們首先用正則匹配這個時間，表達式寫作\d+分鐘前，如果提取到的時間符合這個表達式，那麼就提取出其中的數字，這樣就可以獲取分鐘數了。接下來使用time模塊的strftime()方法，第一個參數傳入要轉換的時間格式，第二個參數就是時間戳。在這裏我們用當前的時間戳減去此分鐘數乘以60就是當時的時間戳，這樣我們就可以得到格式化後的正確時間了。

然後Pipeline可以實現如下處理：

class WeiboPipeline():
    def process_item(self, item, spider):
        if isinstance(item, WeiboItem):
            if item.get('created_at'):
                item['created_at'] = item['created_at'].strip()
                item['created_at'] = self.parse_time(item.get('created_at'))

我們在Spider裏沒有對crawled_at字段賦值，它代表爬取時間，我們可以統一將其賦值爲當前時間，實現如下所示：

class TimePipeline():
    def process_item(self, item, spider):
        if isinstance(item, UserItem) or isinstance(item, WeiboItem):
            now = time.strftime('%Y-%m-%d %H:%M', time.localtime())
            item['crawled_at'] = now
        return item

在這裏我們判斷了Item如果是UserItem或WeiboItem類型，那麼就給它的crawled_at字段賦值爲當前時間。

通過上面的兩個Pipeline，我們便完成了數據清洗工作，這裏主要是時間的轉換。

九、數據存儲

數據清洗完畢之後，我們就要將數據保存到MongoDB數據庫。我們在這裏實現MongoPipeline類，如下所示：

import pymongo

class MongoPipeline(object):
    def __init__(self, mongo_uri, mongo_db):
        self.mongo_uri = mongo_uri
        self.mongo_db = mongo_db

    @classmethod
    def from_crawler(cls, crawler):
        return cls(
            mongo_uri=crawler.settings.get('MONGO_URI'), mongo_db=crawler.settings.get('MONGO_DATABASE')
        )

    def open_spider(self, spider):
        self.client = pymongo.MongoClient(self.mongo_uri)
        self.db = self.client[self.mongo_db]
        self.db[UserItem.collection].create_index([('id', pymongo.ASCENDING)])
        self.db[WeiboItem.collection].create_index([('id', pymongo.ASCENDING)])

    def close_spider(self, spider):
        self.client.close()

    def process_item(self, item, spider):
        if isinstance(item, UserItem) or isinstance(item, WeiboItem):
            self.db[item.collection].update({'id': item.get('id')}, {'$set': item}, True)
        if isinstance(item, UserRelationItem):
            self.db[item.collection].update(
                {'id': item.get('id')},
                {'$addToSet':
                    {
                        'follows': {'$each': item['follows']},
                        'fans': {'$each': item['fans']}
                    }
                }, True)
        return item

當前的MongoPipeline和前面我們所寫的有所不同，主要有以下幾點。

open_spider()方法裏添加了Collection的索引，在這裏爲兩個Item都添加了索引，索引的字段是id。由於我們這次是大規模爬取，爬取過程涉及數據的更新問題，所以我們爲每個Collection建立了索引，這樣可以大大提高檢索效率。
在process_item()方法裏存儲使用的是update()方法，第一個參數是查詢條件，第二個參數是爬取的Item。這裏我們使用了$set操作符，如果爬取到重複的數據即可對數據進行更新，同時不會刪除已存在的字段。如果這裏不加$set操作符，那麼會直接進行item替換，這樣可能會導致已存在的字段如關注和粉絲列表清空。第三個參數設置爲True，如果數據不存在，則插入數據。這樣我們就可以做到數據存在即更新、數據不存在即插入，從而獲得去重的效果。
對於用戶的關注和粉絲列表，我們使用了一個新的操作符，叫作$addToSet，這個操作符可以向列表類型的字段插入數據同時去重。它的值就是需要操作的字段名稱。這裏利用了$each操作符對需要插入的列表數據進行了遍歷，以逐條插入用戶的關注或粉絲數據到指定的字段。關於該操作更多解釋可以參考MongoDB的官方文檔，鏈接爲：https://docs.mongodb.com/manual/reference/operator/update/addToSet/。

十、Cookies池對接

新浪微博的反爬能力非常強，我們需要做一些防範反爬蟲的措施纔可以順利完成數據爬取。

如果沒有登錄而直接請求微博的API接口，這非常容易導致403狀態碼。這個情況我們在Cookies池一節也提過。所以在這裏我們實現一個Middleware，爲每個Request添加隨機的Cookies。

我們先開啓Cookies池，使API模塊正常運行。例如在本地運行5000端口，訪問：http://localhost:5000/weibo/random，即可獲取隨機的Cookies。當然也可以將Cookies池部署到遠程的服務器，這樣只需要更改訪問的鏈接。

我們在本地啓動Cookies池，實現一個Middleware，如下所示：

class CookiesMiddleware():
    def __init__(self, cookies_url):
        self.logger = logging.getLogger(__name__)
        self.cookies_url = cookies_url

    def get_random_cookies(self):
        try:
            response = requests.get(self.cookies_url)
            if response.status_code == 200:
                cookies = json.loads(response.text)
                return cookies
        except requests.ConnectionError:
            return False

    def process_request(self, request, spider):
        self.logger.debug('正在獲取Cookies')
        cookies = self.get_random_cookies()
        if cookies:
            request.cookies = cookies
            self.logger.debug('使用Cookies ' + json.dumps(cookies))

    @classmethod
    def from_crawler(cls, crawler):
        settings = crawler.settings
        return cls(
            cookies_url=settings.get('COOKIES_URL')
        )

我們首先利用from_crawler()方法獲取了COOKIES_URL變量，它定義在settings.py裏，這就是剛纔我們所說的接口。接下來實現get_random_cookies()方法，這個方法主要就是請求此Cookies池接口並獲取接口返回的隨機Cookies。如果成功獲取，則返回Cookies；否則返回False。

接下來，在process_request()方法裏，我們給request對象的cookies屬性賦值，其值就是獲取的隨機Cookies，這樣我們就成功地爲每一次請求賦值Cookies了。

如果啓用了該Middleware，每個請求都會被賦值隨機的Cookies。這樣我們就可以模擬登錄之後的請求，403狀態碼基本就不會出現。

十一、代理池對接

微博還有一個反爬措施就是，檢測到同一IP請求量過大時就會出現414狀態碼。如果遇到這樣的情況可以切換代理。例如，在本地5555端口運行，獲取隨機可用代理的地址爲：http://localhost:5555/random，訪問這個接口即可獲取一個隨機可用代理。接下來我們再實現一個Middleware，代碼如下所示：

class ProxyMiddleware():
    def __init__(self, proxy_url):
        self.logger = logging.getLogger(__name__)
        self.proxy_url = proxy_url

    def get_random_proxy(self):
        try:
            response = requests.get(self.proxy_url)
            if response.status_code == 200:
                proxy = response.text
                return proxy
        except requests.ConnectionError:
            return False

    def process_request(self, request, spider):
        if request.meta.get('retry_times'):
            proxy = self.get_random_proxy()
            if proxy:
                uri = 'https://{proxy}'.format(proxy=proxy)
                self.logger.debug('使用代理 ' + proxy)
                request.meta['proxy'] = uri

    @classmethod
    def from_crawler(cls, crawler):
        settings = crawler.settings
        return cls(
            proxy_url=settings.get('PROXY_URL')
        )

同樣的原理，我們實現了一個get_random_proxy()方法用於請求代理池的接口獲取隨機代理。如果獲取成功，則返回改代理，否則返回False。在process_request()方法中，我們給request對象的meta屬性賦值一個proxy字段，該字段的值就是代理。

另外，賦值代理的判斷條件是當前retry_times不爲空，也就是說第一次請求失敗之後才啓用代理，因爲使用代理後訪問速度會慢一些。所以我們在這裏設置了只有重試的時候才啓用代理，否則直接請求。這樣就可以保證在沒有被封禁的情況下直接爬取，保證了爬取速度。

十二、啓用Middleware

接下來，我們在配置文件中啓用這兩個Middleware，修改settings.py如下所示：

DOWNLOADER_MIDDLEWARES = {
    'weibo.middlewares.CookiesMiddleware': 554,
    'weibo.middlewares.ProxyMiddleware': 555,
}

注意這裏的優先級設置，前文提到了Scrapy的默認Downloader Middleware的設置如下：

{
    'scrapy.downloadermiddlewares.robotstxt.RobotsTxtMiddleware': 100,
    'scrapy.downloadermiddlewares.httpauth.HttpAuthMiddleware': 300,
    'scrapy.downloadermiddlewares.downloadtimeout.DownloadTimeoutMiddleware': 350,
    'scrapy.downloadermiddlewares.defaultheaders.DefaultHeadersMiddleware': 400,
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': 500,
    'scrapy.downloadermiddlewares.retry.RetryMiddleware': 550,
    'scrapy.downloadermiddlewares.ajaxcrawl.AjaxCrawlMiddleware': 560,
    'scrapy.downloadermiddlewares.redirect.MetaRefreshMiddleware': 580,
    'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 590,
    'scrapy.downloadermiddlewares.redirect.RedirectMiddleware': 600,
    'scrapy.downloadermiddlewares.cookies.CookiesMiddleware': 700,
    'scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware': 750,
    'scrapy.downloadermiddlewares.stats.DownloaderStats': 850,
    'scrapy.downloadermiddlewares.httpcache.HttpCacheMiddleware': 900,
}

要使得我們自定義的CookiesMiddleware生效，它在內置的CookiesMiddleware之前調用。內置的CookiesMiddleware的優先級爲700，所以這裏我們設置一個比700小的數字即可。

要使得我們自定義的ProxyMiddleware生效，它在內置的HttpProxyMiddleware之前調用。內置的HttpProxyMiddleware的優先級爲750，所以這裏我們設置一個比750小的數字即可。

十三、運行

到此爲止，整個微博爬蟲就實現完畢了。我們運行如下命令啓動爬蟲：

scrapy crawl weibocn

輸出結果如下所示：

2017-07-11 17:27:34 [urllib3.connectionpool] DEBUG: http://localhost:5000 "GET /weibo/random HTTP/1.1" 200 339
2017-07-11 17:27:34 [weibo.middlewares] DEBUG: 使用Cookies {"SCF": "AhzwTr_DxIGjgri_dt46_DoPzUqq-PSupu545JdozdHYJ7HyEb4pD3pe05VpbIpVyY1ciKRRWwUgojiO3jYwlBE.", "_T_WM": "8fe0bc1dad068d09b888d8177f1c1218", "SSOLoginState": "1501496388", "M_WEIBOCN_PARAMS": "uicode%3D20000174", "SUHB": "0tKqV4asxqYl4J", "SUB": "_2A250e3QUDeRhGeBM6VYX8y7NwjiIHXVXhBxcrDV6PUJbkdBeLXjckW2fUT8MWloekO4FCWVlIYJGJdGLnA.."}
2017-07-11 17:27:34 [weibocn] DEBUG: <200 https://m.weibo.cn/api/container/getIndex?uid=1742566624&type=uid&value=1742566624&containerid=1005051742566624>
2017-07-11 17:27:34 [scrapy.core.scraper] DEBUG: Scraped from <200 https://m.weibo.cn/api/container/getIndex?uid=1742566624&type=uid&value=1742566624&containerid=1005051742566624>
{'avatar': 'https://tva4.sinaimg.cn/crop.0.0.180.180.180/67dd74e0jw1e8qgp5bmzyj2050050aa8.jpg',
 'cover': 'https://tva3.sinaimg.cn/crop.0.0.640.640.640/6ce2240djw1e9oaqhwllzj20hs0hsdir.jpg',
 'crawled_at': '2017-07-11 17:27',
 'description': '成長，就是一個不斷覺得以前的自己是個傻逼的過程',
 'fans_count': 19202906,
 'follows_count': 1599,
 'gender': 'm',
 'id': 1742566624,
 'name': '思想聚焦',
 'verified': True,
 'verified_reason': '微博知名博主，校導網編輯',
 'verified_type': 0,
 'weibos_count': 58393}

運行一段時間後，我們便可以到MongoDB數據庫查看數據，爬取下來的數據如下圖所示。

針對用戶信息，我們不僅爬取了其基本信息，還把關注和粉絲列表加到了follows和fans字段並做了去重操作。針對微博信息，我們成功進行了時間轉換處理，同時還保存了微博的圖片列表信息。

十四、本節代碼

本節代碼地址爲：https://github.com/Python3WebSpider/Weibo。

十五、結語

本節實現了新浪微博的用戶及其粉絲關注列表和微博信息的爬取，還對接了Cookies池和代理池來處理反爬蟲。不過現在是針對單機的爬取，後面我們會將此項目修改爲分佈式爬蟲，以進一步提高抓取效率。

轉自：

https://cloud.tencent.com/developer/user/223114

Wh0ale

發佈了56 篇原創文章 · 獲贊 157 · 訪問量 27萬+

私信關注

scrapy爬取新浪微博+cookie池

一、本節目標

二、準備工作

三、爬取思路

四、爬取分析

五、新建項目

六、創建Item

七、提取數據

八、數據清洗

九、數據存儲

十、Cookies池對接

十一、代理池對接

十二、啓用Middleware

十三、運行

十四、本節代碼

十五、結語

貓眼電影爬取--崔慶才老哥教程記錄

Urllib小結

崔老哥python scrapy爬蟲框架入門

Requests小結

scrapy初探

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結