python爬虫实践

最新推荐文章于 2023-11-14 11:40:04 发布

weixin_33860147

最新推荐文章于 2023-11-14 11:40:04 发布

阅读量483

点赞数

文章标签： python 大数据爬虫

原文链接：http://www.cnblogs.com/tester-l/p/8194690.html

版权

模拟登陆与文件下载

爬取http://moodle.tipdm.com上面的视频并下载

模拟登陆

由于泰迪杯网站问题，测试之后发现无法用正常的账号密码登陆，这里会使用访客账号登陆。

我们先打开泰迪杯的登陆界面，打开开发者工具，选择Network选单，点击访客登陆。

注意到index.php的资源请求是一个POST请求，我们把视窗拉倒最下面，看到表单数据（Form data），浏览器在表单数据中发送了两个变量，分别是username和password，两个变量的值都是guest。这就是我们需要告诉网站的信息了。

知道了这些信息，我们就可以使用requesst来模拟登陆了。

import requests

s = requests.Session()

data = {

'username': 'guest',

'password': 'guest',

}

r = s.post('http://moodle.tipdm.com/login/index.php', data)

print(r.url)

我们引入requests包。但我们这次并没有直接使用request.post()，而是在第二行先创建了一个Session实例s，Session实例可以将浏览过程中的cookies保存下来。cookies指网站为了辨别用户身份而储存在用户本地终端上的数据（通常经过加密）。泰迪网站要聪明一点，就不是只用GET请求传递的数据来确认用户身份，而是要用保存在本地的cookies来确认用户身份（你再也不能伪装成隔壁老王了）。在requests中我们只要创建一个Session实例（比如这里的s），然后之后的请求都用Session实例s来发送，cookies的事情就不用管了。s.post()是用来发送POST请求的（requests.get()发送GET请求）。同理s.get()是用来发送get请求的。POST请求是一定要向服务器发送一个表单数据(form data)的。

我们看到泰迪网站要求上传的表单数据就是username和password，两者的值都是guest，所以在python里面我们创建一个dict，命名为data，里面的数据就输入username和password。最后再用s把数据post到网址，模拟登陆就完成了。

我们运行一下代码，

登陆成功了可以看到网址跳转到了泰迪教程的首页，和在浏览器里面的行为是一样的。这样我吗就实现了模拟登陆一个网站。

视频下载

我们进入到我们要下载的视频的页面（http://moodle.tipdm.com/course/view.php?id=16），然后对要下载的链接进行审查元素。

元素都在`a`标签中，所有这样的a标签(a tag)都在<div class="activityinstance">标签中。所以我们只要找到所有的class为acticityinstance的div标签，然后提取里面a标签的href属性，就知道视频的地址了。同样的，我们使用beautiful soup包来实现我们想要的功能。

from bs4 import BeautifulSoup

r = s.get('http://moodle.tipdm.com/course/view.php?id=16')

soup = BeautifulSoup(r.text, 'lxml')

divs = soup.find_all("div", class_='activityinstance')

for div in divs:

url = div.a.get('href')

print(url)

现在所有的代码看起来应该是这样的：

import requests

from bs4 import BeautifulSoup

data = {

'username': 'guest',

'password': 'guest',

}

s = requests.Session()

r = s.post('http://moodle.tipdm.com/login/index.php', data)

r = s.get('http://moodle.tipdm.com/course/view.php?id=16')

soup = BeautifulSoup(r.text, 'lxml')

divs = soup.find_all("div", class_='activityinstance')

for div in divs:

url = div.a.get('href')

print(url)

运行一下，

你已经拿到了所有的网址我们点开其中的一个网址，看看里面的结构：

可以看到下载链接已经在你面前了，我们对它进行审查元素，看到了一个.mp4的下载地址，那下一步我们就是要获取这个mp4的下载地址。

for div in divs[1:]: # 注意这里也出现了改动

url = div.a.get('href')

r = s.get(url)

soup = BeautifulSoup(r.text, 'lxml')

target_div = soup.find('div', class_='resourceworkaround')

target_url = target_div.a.get('href')

print(target_url)

divs[1:]的意思是我们忽视掉divs列表(list)中的第一个元素，然后进行下面的操作。

到目前为止，你的代码看起来应该是这样的：

import requests

from bs4 import BeautifulSoup

data = {

'username': 'guest',

'password': 'guest',

}

s = requests.Session()

r = s.post('http://moodle.tipdm.com/login/index.php', data)

r = s.get('http://moodle.tipdm.com/course/view.php?id=16')

soup = BeautifulSoup(r.text, 'lxml')

divs = soup.find_all("div", class_='activityinstance')

for div in divs[1:]: # 注意这里也出现了改动

url = div.a.get('href')

r = s.get(url)

soup = BeautifulSoup(r.text, 'lxml')

target_div = soup.find('div', class_='resourceworkaround')

target_url = target_div.a.get('href')

print(target_url)

运行一下代码：

恭喜你，你成功获取到了视频的下载地址。现在将我在这里提供的代码复制到你的代码前面：

def download(url, s):

import urllib, os

file_name = urllib.parse.unquote(url)

file_name = file_name[file_name.rfind('/') + 1:]

try:

r = s.get(url, stream=True, timeout = 2)

chunk_size = 1000

timer = 0

length = int(r.headers['Content-Length'])

print('downloading {}'.format(file_name))

if os.path.isfile('./' + file_name):

print(' file already exist, skipped')

return

with open('./' + file_name, 'wb') as f:

for chunk in r.iter_content(chunk_size):

timer += chunk_size

percent = round(timer/length, 4) * 100

print('\r {:4f}'.format((percent)), end = '')

f.write(chunk)

print('\r finished ')

except requests.exceptions.ReadTimeout:

print('read time out, this file failed to download')

return

except requests.exceptions.ConnectionError:

print('ConnectionError, this file failed to download')

return

然后在你循环的末尾加上download(target_url, s)

现在整个代码看起来是这样的：

import requests

from bs4 import BeautifulSoup

data = {

'username': 'guest',

'password': 'guest',

}

def download(url, s):

import urllib, os

file_name = urllib.parse.unquote(url)

file_name = file_name[file_name.rfind('/') + 1:]

try:

r = s.get(url, stream=True, timeout = 2)

chunk_size = 1000

timer = 0

length = int(r.headers['Content-Length'])

print('downloading {}'.format(file_name))

if os.path.isfile('./' + file_name):

print(' file already exist, skipped')

return

with open('./' + file_name, 'wb') as f:

for chunk in r.iter_content(chunk_size):

timer += chunk_size

percent = round(timer/length, 4) * 100

print('\r {:4f}'.format((percent)), end = '')

f.write(chunk)

print('\r finished ')

except requests.exceptions.ReadTimeout:

print('read time out, this file failed to download')

return

except requests.exceptions.ConnectionError:

print('ConnectionError, this file failed to download')

return

s = requests.Session()

r = s.post('http://moodle.tipdm.com/login/index.php', data)

r = s.get('http://moodle.tipdm.com/course/view.php?id=16')

soup = BeautifulSoup(r.text, 'lxml')

divs = soup.find_all("div", class_='activityinstance')

for div in divs[1:]:

url = div.a.get('href')

r = s.get(url)

soup = BeautifulSoup(r.text, 'lxml')

target_div = soup.find('div', class_='resourceworkaround')

target_url = target_div.a.get('href')

download(target_url, s)

运行一下，视频已经开始下载了

这样你已经成功学会了如何模拟登陆一个网站，并且学会了如何从网站上面下载一个文件。

排行榜小说批量下载

我们要爬取的是小说，排行榜的地址：http://www.qu.la/paihangbang/。先观察下网页的结构

很容易就能发现，每一个分类都是包裹在：<div class="index_toplist mright mbottom">之中，这种条理清晰的网站，大大方便了爬虫的编写。在当前页面找到所有小说的连接，并保存在列表即可。这里有个问题，就算是不同类别的小说，也是会重复出现在排行榜的。这样无形之间就会浪费爬取时间。解决方法就是：url_list = list(set(url_list)) 这里调用了一个list的构造函数set：这样就能保证列表里没有重复的元素了。

代码实现

1.网页抓取头：

import requests

from bs4 import BeautifulSoup

def get_html(url):

try:

r = requests.get(url,timeout=30)

r.raise_for_status

r.encoding='utf-8'

return r.text

except:

return 'error!'

2.获取排行榜小说及其链接：

爬取每一类型小说排行榜，按顺序写入文件，文件内容为：小说名字+小说链接将内容保存到列表并且返回一个装满url链接的列表

def get_content(url):

url_list = []

html = get_html(url)

soup = BeautifulSoup(html,'lxml')

# 由于小说排版的原因，历史类和完本类小说不在一个div里

category_list = soup.find_all('div',class_='index_toplist mright mbottom')

history_list = soup.find_all('div',class_='index_toplist mbottom')

for cate in category_list:

name = cate.find('div',class_='toptab').span.text

with open('novel_list.csv','a+') as f:

f.write('\n小说种类：{} \n'.format(name))

book_list = cate.find('div',class_='topbooks').find_all('li')

# 循环遍历出每一个小说的的名字，以及链接

for book in book_list:

link = 'http://www.qu.la/' + book.a['href']

title = book.a['title']

url_list.append(link)

# 这里使用a模式写入，防止清空文件

with open('novel_list.csv','a') as f:

f.write('小说名:{} \t 小说地址:{} \n'.format(title,link))

for cate in history_list:

name = cate.find('div',class_='toptab').span.text

with open('novel_list.csv','a') as f:

f.write('\n小说种类: {} \n'.format(name))

book_list = cate.find('div',class_='topbooks').find_all('li')

for book in book_list:

link = 'http://www.qu.la/' + book.a['href']

title = book.a['title']

url_list.append(link)

with open('novel_list.csv','a') as f:

f.write('小说名:{} \t 小说地址:{} \n'.format(title,link))

return url_list

3.获取单本小说的所有章节链接:

获取该小说每个章节的url地址，并创建小说文件

# 获取单本小说的所有章节链接

def get_txt_url(url):

url_list = []

html = get_html(url)

soup = BeautifulSoup(html,'lxml')

list_a = soup.find_all('dd')

txt_name = soup.find('dt').text

with open('C:/Users/Administrator/Desktop/小说/{}.txt'.format(txt_name),'a+') as f:

f.write('小说标题：{} \n'.format(txt_name))

for url in list_a:

url_list.append('http://www.qu.la/' + url.a['href'])

return url_list,txt_name

4.获取单页文章的内容并保存到本地

从网上爬下来的文件很多时候都是带着<br>之类的格式化标签，可以通过一个简单的方法把它过滤掉：
html = get_html(url).replace('<br/>', '\n')
这里单单过滤了一种标签，并将其替换成‘\n’用于文章的换行，

def get_one_txt(url,txt_name):

html = get_html(url).replace('<br/>','\n')

soup = BeautifulSoup(html,'lxml')

try:

txt = soup.find('div',id='content').text

title = soup.find('h1').text

with open('C:/Users/Administrator/Desktop/小说/{}.txt'.format(txt.name),'a') as f:

f.write(title + '\n\n')

f.write(txt)

print('当前小说：{}当前章节{}已经下载完毕'.format(txt_name,title))

except:

print('ERROR!')

5.主函数

def get_all_txt(url_list):

for url in url_list:

# 遍历获取当前小说的所有章节的目录，并且生成小说头文件

page_list,txt_name = get_txt_url(url)

def main():

# 小说排行榜地址

base_url = 'http://www.qu.la/paihangbang/'

# 获取排行榜中所有小说的url链接

url_list = get_content(base_url)

# 除去重复的小说

url_list = list(set(url_list))

get_all_txt(url_list)

if __name__ == '__main__':

main()

6.输出结果

多线程爬虫

最近想要抓取拉勾网的数据，最开始是使用Scrapy的，但是遇到了下面两个问题:1前端页面是用JS模板引擎生成的2接口主要是用POST提交参数的

目前不会处理使用JS模板引擎生成的HTML页面，用POST的提交参数的话，接口统一，也没有必要使用Scrapy，所以就萌生了自己写一个简单的Python爬虫的想法。该爬虫框架主要就是处理网络请求，这个简单的爬虫使用多线程来处理网络请求，使用线程来处理URL队列中的url，然后将url返回的结果保存在另一个队列中，其它线程读取这个队列中的数据，然后写到文件中去。该爬虫主要用下面几个部分组成。

1 URL队列和结果队列

将将要爬取的url放在一个队列中，这里使用标准库Queue。访问url后的结果保存在结果队列中

初始化一个URL队列

from Queue import Queue

urls_queue = Queue()

out_queue = Queue()

2 请求线程

使用多个线程，不停的取URL队列中的url，并进行处理：

import threading

class ThreadCrawl(threading.Thread):

def __init__(self, queue, out_queue):

threading.Thread.__init__(self)

self.queue = queue

self.out_queue = out_queue

def run(self):

while True:

item = self.queue.get()

self.queue.task_down()

如果队列为空，线程就会被阻塞，直到队列不为空。处理队列中的一条数据后，就需要通知队列已经处理完该条数据。

3 处理线程

处理结果队列中的数据，并保存到文件中。如果使用多个线程的话，必须要给文件加上锁。

lock = threading.Lock()

f = codecs.open('out.txt', 'w', 'utf8')

当线程需要写入文件的时候，可以这样处理：

with lock:

f.write(something)

抓取结果：

源码

代码还不完善，将会持续修改中。

from Queue import Queue

import threading

import urllib2

import time

import json

import codecs

from bs4 import BeautifulSoup

urls_queue = Queue()

data_queue = Queue()

lock = threading.Lock()

f = codecs.open('out.txt', 'w', 'utf8')

class ThreadUrl(threading.Thread):

def __init__(self, queue):

threading.Thread.__init__(self)

self.queue = queue

def run(self):

pass

class ThreadCrawl(threading.Thread):

def __init__(self, url, queue, out_queue):

threading.Thread.__init__(self)

self.url = url

self.queue = queue

self.out_queue = out_queue

def run(self):

while True:

item = self.queue.get()

data = self._data_post(item)

try:

req = urllib2.Request(url=self.url, data=data)

res = urllib2.urlopen(req)

except urllib2.HTTPError, e:

raise e.reason

py_data = json.loads(res.read())

res.close()

item['first'] = 'false'

item['pn'] = item['pn'] + 1

success = py_data['success']

if success:

print 'Get success...'

else:

print 'Get fail....'

print 'pn is : %s' % item['pn']

result = py_data['content']['result']

if len(result) != 0:

self.queue.put(item)

print 'now queue size is: %d' % self.queue.qsize()

self.out_queue.put(py_data['content']['result'])

self.queue.task_done()

def _data_post(self, item):

pn = item['pn']

first = 'false'

if pn == 1:

first = 'true'

return 'first=' + first + '&pn=' + str(pn) + '&kd=' + item['kd']

def _item_queue(self):

pass

class ThreadWrite(threading.Thread):

def __init__(self, queue, lock, f):

threading.Thread.__init__(self)

self.queue = queue

self.lock = lock

self.f = f

def run(self):

while True:

item = self.queue.get()

self._parse_data(item)

self.queue.task_done()

def _parse_data(self, item):

for i in item:

l = self._item_to_str(i)

with self.lock:

print 'write %s' % l

self.f.write(l)

def _item_to_str(self, item):

positionName = item['positionName']

positionType = item['positionType']

workYear = item['workYear']

education = item['education']

jobNature = item['jobNature']

companyName = item['companyName']

companyLogo = item['companyLogo']

industryField = item['industryField']

financeStage = item['financeStage']

companyShortName = item['companyShortName']

city = item['city']

salary = item['salary']

positionFirstType = item['positionFirstType']

createTime = item['createTime']

positionId = item['positionId']

return positionName + ' ' + positionType + ' ' + workYear + ' ' + education + ' ' + \

jobNature + ' ' + companyLogo + ' ' + industryField + ' ' + financeStage + ' ' + \

companyShortName + ' ' + city + ' ' + salary + ' ' + positionFirstType + ' ' + \

createTime + ' ' + str(positionId) + '\n'

def main():

for i in range(4):

t = ThreadCrawl(

'http://www.lagou.com/jobs/positionAjax.json', urls_queue, data_queue)

t.setDaemon(True)

t.start()

datas = [

{'first': 'true', 'pn': 1, 'kd': 'Java'}

#{'first': 'true', 'pn': 1, 'kd': 'Python'}

]

for d in datas:

urls_queue.put(d)

for i in range(4):

t = ThreadWrite(data_queue, lock, f)

t.setDaemon(True)

t.start()

urls_queue.join()

data_queue.join()

with lock:

f.close()

print 'data_queue siez: %d' % data_queue.qsize()

main()

爬虫的基本流程

网络爬虫的基本工作流程如下：

●首先选取一部分精心挑选的种子URL

●将种子URL加入任务队列

●从待抓取URL队列中取出待抓取的URL，解析DNS，并且得到主机的ip，并将URL对应的网页下载下来，存储进已下载网页库中。此外，将这些URL放进已抓取URL队列。

●分析已抓取URL队列中的URL，分析其中的其他URL，并且将URL放入待抓取URL队列，从而进入下一个循环。

●解析下载下来的网页，将需要的数据解析出来。

●数据持久话，保存至数据库中。

爬虫的抓取策略

在爬虫系统中，待抓取URL队列是很重要的一部分。待抓取URL队列中的URL以什么样的顺序排列也是一个很重要的问题，因为这涉及到先抓取那个页面，后抓取哪个页面。而决定这些URL排列顺序的方法，叫做抓取策略。下面重点介绍几种常见的抓取策略：

●深度优先策略(DFS) 深度优先策略是指爬虫从某个URL开始，一个链接一个链接的爬取下去，直到处理完了某个链接所在的所有线路，才切换到其它的线路。
此时抓取顺序为：A -> B -> C -> D -> E -> F -> G -> H -> I -> J

●广度优先策略(BFS) 宽度优先遍历策略的基本思路是，将新下载网页中发现的链接直接插入待抓取URL队列的末尾。也就是指网络爬虫会先抓取起始网页中链接的所有网页，然后再选择其中的一个链接网页，继续抓取在此网页中链接的所有网页。此时抓取顺序为：A -> B -> E -> G -> H -> I -> C -> F -> J -> D

技术栈

●requests 人性化的请求发送

●Bloom Filter 布隆过滤器，用于判重

●XPath 解析HTML内容

●murmurhash

●Anti crawler strategy 反爬虫策略

●MySQL 用户数据存储

1 调研目标网站背景

1.1 检查robots.txt

http://example.webscraping.com/robots.txt

# section 1

User-agent: BadCrawler

Disallow: /

# section 2

User-agent: *

Crawl-delay: 5

Disallow: /trap

# section 3

Sitemap: http://example.webscraping.com/sitemap.xml

●section 1 ：禁止用户代理为BadCrawler的爬虫爬取该网站，除非恶意爬虫。

●section 2 ：两次下载请求时间间隔5秒的爬取延迟。/trap 用于封禁恶意爬虫，会封禁1分钟不止。

●section 3 ：定义一个Sitemap文件，下节讲。

1.2 检查网站地图

所有网页链接： http://example.webscraping.com/sitemap.xml

<url>

<loc>http://example.webscraping.com/view/Afghanistan-1</loc>

</url>

<url>

<loc>

http://example.webscraping.com/view/Aland-Islands-2

</loc>

</url>

...

<url>

<loc>http://example.webscraping.com/view/Zimbabwe-252</loc>

</url>

</urlset>

1.3 估算网站大小

高级搜索参数：http://www.google.com/advanced_search
Google搜索：site:http://example.webscraping.com/ 有202个网页
Google搜索：site:http://example.webscraping.com/view 有117个网页

1.4 识别网站所有技术

用buildwith模块可以检查网站构建的技术类型。
安装库：pip install buildwith

>>> import builtwith

>>> builtwith.parse('http://example.webscraping.com')

{u'javascript-frameworks': [u'jQuery', u'Modernizr', u'jQuery UI'],

u'web-frameworks': [u'Web2py', u'Twitter Bootstrap'],

u'programming-languages': [u'Python'],

u'web-servers': [u'Nginx']}

>>>

示例网址使用了Python的Web2py框架，还使用了JavaScript库，可能是嵌入在HTML中的。这种容易抓取。其他建构类型：
- AngularJS：内容动态加载
- ASP.NET：爬取网页要用到会话管理和表单提交。

基本实现

下面是一个伪代码

import Queue

initial_page = "https://www.zhihu.com/people/gaoming623"

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

如果你直接加工一下上面的代码直接运行的话，你需要很长的时间才能爬下整个知乎用户的信息，毕竟知乎有6000万月活跃用户。更别说Google这样的搜索引擎需要爬下全网的内容了。那么问题出现在哪里？

布隆过滤器

需要爬的网页实在太多太多了，而上面的代码太慢太慢了。设想全网有N个网站，那么分析一下判重的复杂度就是N*log(N)，因为所有网页要遍历一次，而每次判重用set的话需要log(N)的复杂度。OK，我知道python的set实现是hash——不过这样还是太慢了，至少内存使用效率不高。通常的判重做法是怎样呢？Bloom Filter. 简单讲它仍然是一种hash的方法，但是它的特点是，它可以使用固定的内存（不随url的数量而增长）以O(1)的效率判定url是否已经在set中。可惜天下没有白吃的午餐，它的唯一问题在于，如果这个url不在set中，BF可以100%确定这个url没有看过。但是如果这个url在set中，它会告诉你：这个url应该已经出现过，不过我有2%的不确定性。注意这里的不确定性在你分配的内存足够大的时候，可以变得很小很少。

# bloom_filter.py

BIT_SIZE = 5000000

class BloomFilter:

def __init__(self):

# Initialize bloom filter, set size and all bits to 0

bit_array = bitarray(BIT_SIZE)

bit_array.setall(0)

self.bit_array = bit_array

def add(self, url):

# Add a url, and set points in bitarray to 1 (Points count is equal to hash funcs count.)

# Here use 7 hash functions.

point_list = self.get_postions(url)

for b in point_list:

self.bit_array[b] = 1

def contains(self, url):

# Check if a url is in a collection

point_list = self.get_postions(url)

result = True

for b in point_list:

result = result and self.bit_array[b]

return result

def get_postions(self, url):

# Get points positions in bit vector.

point1 = mmh3.hash(url, 41) % BIT_SIZE

point2 = mmh3.hash(url, 42) % BIT_SIZE

point3 = mmh3.hash(url, 43) % BIT_SIZE

point4 = mmh3.hash(url, 44) % BIT_SIZE

point5 = mmh3.hash(url, 45) % BIT_SIZE

point6 = mmh3.hash(url, 46) % BIT_SIZE

point7 = mmh3.hash(url, 47) % BIT_SIZE

return [point1, point2, point3, point4, point5, point6, point7]

建表

用户有价值的信息包括用户名、简介、行业、院校、专业及在平台上活动的数据比如回答数、文章数、提问数、粉丝数等等。

用户信息存储的表结构如下：

CREATE DATABASE `zhihu_user` /*!40100 DEFAULT CHARACTER SET utf8 */;

-- User base information table

CREATE TABLE `t_user` (

`uid` bigint(20) unsigned NOT NULL AUTO_INCREMENT,

`username` varchar(50) NOT NULL COMMENT '用户名',

`brief_info` varchar(400) COMMENT '个人简介',

`industry` varchar(50) COMMENT '所处行业',

`education` varchar(50) COMMENT '毕业院校',

`major` varchar(50) COMMENT '主修专业',

`answer_count` int(10) unsigned DEFAULT 0 COMMENT '回答数',

`article_count` int(10) unsigned DEFAULT 0 COMMENT '文章数',

`ask_question_count` int(10) unsigned DEFAULT 0 COMMENT '提问数',

`collection_count` int(10) unsigned DEFAULT 0 COMMENT '收藏数',

`follower_count` int(10) unsigned DEFAULT 0 COMMENT '被关注数',

`followed_count` int(10) unsigned DEFAULT 0 COMMENT '关注数',

`follow_live_count` int(10) unsigned DEFAULT 0 COMMENT '关注直播数',

`follow_topic_count` int(10) unsigned DEFAULT 0 COMMENT '关注话题数',

`follow_column_count` int(10) unsigned DEFAULT 0 COMMENT '关注专栏数',

`follow_question_count` int(10) unsigned DEFAULT 0 COMMENT '关注问题数',

`follow_collection_count` int(10) unsigned DEFAULT 0 COMMENT '关注收藏夹数',

`gmt_create` datetime NOT NULL COMMENT '创建时间',

`gmt_modify` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '最后一次编辑',

PRIMARY KEY (`uid`)

) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='用户基本信息表';

网页下载后通过XPath进行解析，提取用户各个维度的数据，最后保存到数据库中。

反爬虫策略应对-Headers

一般网站会从几个维度来反爬虫：用户请求的Headers，用户行为，网站和数据加载的方式。从用户请求的Headers反爬虫是最常见的策略，很多网站都会对Headers的User-Agent进行检测，还有一部分网站会对Referer进行检测（一些资源网站的防盗链就是检测Referer）。

如果遇到了这类反爬虫机制，可以直接在爬虫中添加Headers，将浏览器的User-Agent复制到爬虫的Headers中；或者将Referer值修改为目标网站域名。对于检测Headers的反爬虫，在爬虫中修改或者添加Headers就能很好的绕过。

cookies = {

"d_c0": "AECA7v-aPwqPTiIbemmIQ8abhJy7bdD2VgE=|1468847182",

"login": "NzM5ZDc2M2JkYzYwNDZlOGJlYWQ1YmI4OTg5NDhmMTY=|1480901173|9c296f424b32f241d1471203244eaf30729420f0",

"n_c": "1",

"q_c1": "395b12e529e541cbb400e9718395e346|1479808003000|1468847182000",

"l_cap_id": "NzI0MTQwZGY2NjQyNDQ1NThmYTY0MjJhYmU2NmExMGY=|1480901160|2e7a7faee3b3e8d0afb550e8e7b38d86c15a31bc",

"d_c0": "AECA7v-aPwqPTiIbemmIQ8abhJy7bdD2VgE=|1468847182",

"cap_id": "N2U1NmQwODQ1NjFiNGI2Yzg2YTE2NzJkOTU5N2E0NjI=|1480901160|fd59e2ed79faacc2be1010687d27dd559ec1552a"

}

headers = {

"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.98 Safari/537.3",

"Referer": "https://www.zhihu.com/"

}

r = requests.get(url, cookies = cookies, headers = headers)

反爬虫策略应对-代理IP池

还有一部分网站是通过检测用户行为，例如同一IP短时间内多次访问同一页面，或者同一账户短时间内多次进行相同操作。

大多数网站都是前一种情况，对于这种情况，使用IP代理就可以解决。这样的代理ip爬虫经常会用到，最好自己准备一个。有了大量代理ip后可以每请求几次更换一个ip，这在requests或者urllib2中很容易做到，这样就能很容易的绕过第一种反爬虫。目前知乎已经对爬虫做了限制，如果是单个IP的话，一段时间系统便会提示异常流量，无法继续爬取了。因此代理IP池非常关键。网上有个免费的代理IP API: http://api.xicidaili.com/free2016.txt