每日站长统计
&&IP：610 条
&&IP：75 条
&&IP：535 条
操作总数：1402 条
运行天数：614 天
建站时间：
最后更新：
每日站长统计
&&IP：610 条
&&IP：75 条
&&IP：535 条
操作总数：1402 条
运行天数：614 天
建站时间：
最后更新：
闹市重声(默认)
用户名或电子邮件地址7.5K134 条评论分享收藏感谢收起赞同 11K225 条评论分享收藏感谢收起一些常用的爬虫技巧归纳与以下几点：
1、基本抓取网页
import urllib2
url "http://www.baidu.com"
respons = urllib2.urlopen(url)
print response.read()
import urllib
import urllib2
url = "http://abcde.com"
form = {'name':'abc','password':'1234'}
form_data = urllib.urlencode(form)
request = urllib2.Request(url,form_data)
response = urllib2.urlopen(request)
print response.read()
2、使用代理IP
在开发爬虫过程中经常会遇到IP被封掉的情况，这时就需要用到代理IP；
在urllib2包中有ProxyHandler类，通过此类可以设置代理访问网页，如下代码片段：
import urllib2
proxy = urllib2.ProxyHandler({'http': '127.0.0.1:8087'})
opener = urllib2.build_opener(proxy)
urllib2.install_opener(opener)
response = urllib2.urlopen('http://www.baidu.com')
print response.read()
3、Cookies处理
cookies是某些网站为了辨别用户身份、进行session跟踪而储存在用户本地终端上的数据(通常经过加密)，python提供了cookielib模块用于处理cookies，cookielib模块的主要作用是提供可存储cookie的对象，以便于与urllib2模块配合使用来访问Internet资源.
代码片段：
import urllib2, cookielib
cookie_support=urllib2.HTTPCookieProcessor(cookielib.CookieJar())
opener = urllib2.build_opener(cookie_support)
urllib2.install_opener(opener)
content = urllib2.urlopen('http://XXXX').read()
关键在于CookieJar()，它用于管理HTTP cookie值、存储HTTP请求生成的cookie、向传出的HTTP请求添加cookie的对象。整个cookie都存储在内存中，对CookieJar实例进行垃圾回收后cookie也将丢失，所有过程都不需要单独去操作。
手动添加cookie
cookie = "PHPSESSID=91rurfqm2329bopnosfu4fvmu7; kmsign=55d2c12c9b1e3; KMUID=b6Ejc1XSwPq9o756AxnBAg="
request.add_header("Cookie", cookie)
4、伪装成浏览器
某些网站反感爬虫的到访，于是对爬虫一律拒绝请求。所以用urllib2直接访问网站经常会出现HTTP Error 403: Forbidden的情况
对有些 header 要特别留意，Server 端会针对这些 header 做检查
1).User-Agent 有些 Server 或 Proxy 会检查该值，用来判断是否是浏览器发起的 Request
2).Content-Type 在使用 REST 接口时，Server 会检查该值，用来确定 HTTP Body 中的内容该怎样解析。
这时可以通过修改http包中的header来实现，代码片段如下：
import urllib2
headers = {
'User-Agent':'Mozilla/5.0 (W U; Windows NT 6.1; en-US; rv:1.9.1.6) Gecko/ Firefox/3.5.6'
request = urllib2.Request(
url = 'http://my.oschina.net/jhao104/blog?catalog=3463517',
headers = headers
print urllib2.urlopen(request).read()
5、页面解析
对于页面解析最强大的当然是正则表达式，这个对于不同网站不同的使用者都不一样，就不用过多的说明
6、验证码的处理
对于一些简单的验证码，可以进行简单的识别。本人也只进行过一些简单的验证码识别。但是有些反人类的验证码，比如12306，可以通过打码平台进行人工打码，当然这是要付费的。
7、gzip压缩
有没有遇到过某些网页，不论怎么转码都是一团乱码。哈哈，那说明你还不知道许多web服务具有发送压缩数据的能力，这可以将网络线路上传输的大量数据消减 60% 以上。这尤其适用于 XML web 服务，因为 XML 数据 的压缩率可以很高。
但是一般服务器不会为你发送压缩数据，除非你告诉服务器你可以处理压缩数据。
于是需要这样修改代码：
import urllib2, httplib
request = urllib2.Request('http://xxxx.com')
request.add_header('Accept-encoding', 'gzip') 1
opener = urllib2.build_opener()
f = opener.open(request)
这是关键:创建Request对象，添加一个 Accept-encoding 头信息告诉服务器你能接受 gzip 压缩数据
然后就是解压缩数据：
import StringIO
import gzip
compresseddata = f.read()
compressedstream = StringIO.StringIO(compresseddata)
gzipper = gzip.GzipFile(fileobj=compressedstream)
print gzipper.read()
8、多线程并发抓取
单线程太慢的话，就需要多线程了，这里给个简单的线程池模板 这个程序只是简单地打印了1-10，但是可以看出是并发的。
虽然说python的多线程很鸡肋，但是对于爬虫这种网络频繁型，还是能一定程度提高效率的。
from threading import Thread
from Queue import Queue
from time import sleep
q = Queue()
def do_somthing_using(arguments):
print arguments
def working():
while True:
arguments = q.get()
do_somthing_using(arguments)
q.task_done()
alert(“Hello CSDN”);
for i in range(NUM):
t = Thread(target=working)
t.setDaemon(True)
for i in range(JOBS):
整理不易，如果觉得有所帮助，希望可以留下您的精彩言论再走。赶快为你们最喜欢的框架打Call吧。
大家如果想要学习Python可以加我的Qun：834+179+111，小编整理了2018最新的学习资料和大神分享直播。欢迎还没有找到方向的小伙伴来学习。
本文转自网络
如有侵权 请联系小编删除
给大家整理了一篇Python 的异常处理
Python在执行代码之前，会进行语法检查，如果语法出错了，会抛出语法错误（SyntaxError）。
Python程序运行期间检测到的错误被称为异常。
给大家整理了一篇Python的文件操作
总是记不住API。昨晚写的时候用到了这些，但是没记住，于是就索性整理一下吧：
python中对文件、文件夹（文件操作函数）的操作需要涉及到os模块和shutil模块。
得到当前工作目录，即当前Py...
给大家整理了一篇关于Python正则表达式的资料
一、基本函数（match、search、findall）
　　在使用re模块之前，要先引入，re模块使已经在内置在Python内部的，无需再自己下载安装了。
1 import re
1、re.m...
Python爬虫：一些常用的爬虫技巧总结
1、基本抓取网页
2、使用代理IP
3、Cookies处理
4、伪装成浏览器
5、页面解析
6、验证码的处理
7、gzip压缩
年底了，整理了一些Android面试题给大家
年底了，很多人都会考虑是否换一份工作，我整理了一点能想到的Android面试题目，虽然有半年多已经完全没做Android了。也看看自己还能想起哪些？1、本地广播和全局广播有什么差别？2、Broadca...
python资源大合集
这里有最全的python资源，整理自各个经典书籍和网站https://github.com/hotface
找实习心得（Python爬虫）
既昨天收到天润融通的Offer之后（虽然觉得自己的面试表现比较差，但是可能还是由于学校的关系吧，有一些优势），今天陆续收到了两个面试通知。在拉勾网和Boss网这样的网站上搜索相关实习，然后投简历感觉比...
[Python学习] 简单网络爬虫抓取博客文章及思想介绍
前面一直强调Python运用到网络爬虫方面非常有效,这篇文章也是结合学习的Python视频知识及我研究生数据挖掘方向的知识.从而简单介绍下Python是如何爬去网络数据的,文章知识非常简单,但是也分享...
Python 3.x爬虫技巧总结
最近想下载一些陌声人广播，在回家的火车上听，但是链接太多，如果要一个个去点就太浪费时间了，所以就想写一个爬虫自动下载。
用python爬虫抓站的一些技巧总结这篇文章对python爬虫技巧总结得很好，但...
没有更多推荐了，Python文件练习_查找log中的IP并统计 - 进击的菜鸟啊 - 博客园
需求：监控日志，如果有攻击，就把ip加入黑名单
　　1、打开日志文件，读取文件中的所有的内容
　　2、提取内容中的ip
　　3、把ip放入到列表中去，在用set去重，得到独立不同的ip数
　　4、循环set中的ip，到list中去进行ip个数的统计，超过50次的加入到黑名单
　　日志信息如下：
178.210.90.90 - - [04/Jun/:13 +0800] "GET /wp-includes/logo_img.php HTTP/1.0" 302 161 "http://nnzhp.cn/wp-includes/logo_img.php" "Mozilla/5.0 (W U; Windows NT 5.1; en-US) AppleWebKit/533.4 (KHTML, like Gecko) Chrome/5.0.375.99 Safari/533.4" "10.3.152.221"
178.210.90.90 - - [04/Jun/:13 +0800] "GET /blog HTTP/1.0" 301 233 "http://nnzhp.cn/wp-includes/logo_img.php" "Mozilla/5.0 (W U; Windows NT 5.1; en-US) AppleWebKit/533.4 (KHTML, like Gecko) Chrome/5.0.375.99 Safari/533.4" "10.3.152.221"
178.210.90.90 - - [04/Jun/:15 +0800] "GET /blog/ HTTP/1.0" 200 38278 "http://nnzhp.cn/wp-includes/logo_img.php" "Mozilla/5.0 (W U; Windows NT 5.1; en-US) AppleWebKit/533.4 (KHTML, like Gecko) Chrome/5.0.375.99 Safari/533.4" "10.3.152.221"
66.249.75.29 - - [04/Jun/:55 +0800] "GET /bbs/forum.php?mod=forumdisplay&fid=574&filter=hot HTTP/1.1" 200 17482 "-" "Mozilla/5.0 ( Googlebot/2.1; +http://www.google.com/bot.html)" "-"
37.9.169.20 - - [04/Jun/:59 +0800] "GET /wp-admin/security.php HTTP/1.1" 302 161 "http://nnzhp.cn/wp-admin/s
import timecount=0
#初始的文件指针设置为0while True:
ip_list = []
#每次循环时把列表清空，因为是按1分钟进行统计的
with open("access.log","r",encoding="utf-8") as fr:
fr.seek(count)
#根据文件指针进行文件内容读取
for line in fr:
#循环拿每一行内容
ip_list.append(line.split("-")[0])
#取每一行的ip
count=fr.tell()
#读完之后更新文件的指针
for ip in set(ip_list):
#循环读取集合中的ip并到列表中进行统计
if ip_list.count(ip)&50:
print("把ip为%s的加入到黑名单"%ip)
fr.close()
#最后关闭文件句柄
time.wait(60)
　　　　　　搜索是大数据领域里常见的需求。Splunk和ELK分别是该领域在非开源和开源领域里的领导者。本文利用很少的Python代码实现了一个基本的数据搜索功能，试图让大家理解大数据搜索的基本原理。
布隆过滤器 （Bloom Filter）
第一步我们先要实现一个。
布隆过滤器是大数据领域的一个常见算法，它的目的是过滤掉那些不是目标的元素。也就是说如果一个要搜索的词并不存在与我的数据中，那么它可以以很快的速度返回目标不存在。
让我们看看以下布隆过滤器的代码：
class Bloomfilter(object):
A Bloom filter is a probabilistic data-structure that trades space for accuracy
when determining if a value is in a set.
It can tell you if a value was possibly
added, or if it was definitely not added, but it can't tell you for certain that
it was added.
def __init__(self, size):
"""Setup the BF with the appropriate size"""
self.values = [False] * size
self.size = size
def hash_value(self, value):
"""Hash the value provided and scale it to fit the BF size"""
return hash(value) % self.size
def add_value(self, value):
"""Add a value to the BF"""
h = self.hash_value(value)
self.values[h] = True
def might_contain(self, value):
"""Check if the value might be in the BF"""
h = self.hash_value(value)
return self.values[h]
def print_contents(self):
"""Dump the contents of the BF for debugging purposes"""
print self.values
基本的数据结构是个数组（实际上是个位图，用1/0来记录数据是否存在），初始化是没有任何内容，所以全部置False。实际的使用当中，该数组的长度是非常大的，以保证效率。利用哈希算法来决定数据应该存在哪一位，也就是数组的索引当一个数据被加入到布隆过滤器的时候，计算它的哈希值然后把相应的位置为True当检查一个数据是否已经存在或者说被索引过的时候，只要检查对应的哈希值所在的位的True／Fasle看到这里，大家应该可以看出，如果布隆过滤器返回False，那么数据一定是没有索引过的，然而如果返回True，那也不能说数据一定就已经被索引过。在搜索过程中使用布隆过滤器可以使得很多没有命中的搜索提前返回来提高效率。
我们看看这段 code是如何运行的：
bf = Bloomfilter(10)
bf.add_value('dog')
bf.add_value('fish')
bf.add_value('cat')
bf.print_contents()
bf.add_value('bird')
bf.print_contents()
for term in ['dog', 'fish', 'cat', 'bird', 'duck', 'emu']:
print '{}: {} {}'.format(term, bf.hash_value(term), bf.might_contain(term))
[False, False, False, False, True, True, False, False, False, True]
[False, False, False, False, True, True, False, False, False, True]
dog: 5 True
fish: 4 True
cat: 9 True
bird: 9 True
duck: 5 True
emu: 8 False
首先创建了一个容量为10的的布隆过滤器
然后分别加入 ‘dog’，‘fish’，‘cat’三个对象，这时的布隆过滤器的内容如下：
然后加入‘bird’对象，布隆过滤器的内容并没有改变，因为‘bird’和‘fish’恰好拥有相同的哈希。
最后我们检查一堆对象（’dog’, ‘fish’, ‘cat’, ‘bird’, ‘duck’, ‘emu’）是不是已经被索引了。结果发现‘duck’返回True，2而‘emu’返回False。因为‘duck’的哈希恰好和‘dog’是一样的。
下面一步我们要实现分词。 分词的目的是要把我们的文本数据分割成可搜索的最小单元，也就是词。这里我们主要针对英语，因为中文的分词涉及到自然语言处理，比较复杂，而英文基本只要用标点符号就好了。
下面我们看看分词的代码：
def major_segments(s):
Perform major segmenting on a string.
Split the string by all of the major
breaks, and return the set of everything found.
The breaks in this implementation
are single characters, but in Splunk proper they can be multiple characters.
A set is used because ordering doesn't matter, and duplicates are bad.
major_breaks = ' '
results = set()
for idx, ch in enumerate(s):
if ch in major_breaks:
segment = s[last+1:idx]
results.add(segment)
last = idx
segment = s[last+1:]
results.add(segment)
return results
主要分割使用空格来分词，实际的分词逻辑中，还会有其它的分隔符。例如Splunk的缺省分割符包括以下这些，用户也可以定义自己的分割符。
] & & ( ) { } | ! ; , ’ ” * \n \r \s \t & ? + %21 %26 %2526 %3B %7C %20 %2B %3D – %2520 %5D %5B %3A %0A %2C %28 %29
def minor_segments(s):
Perform minor segmenting on a string.
This is like major
segmenting, except it also captures from the start of the
input to each break.
minor_breaks = '_.'
results = set()
for idx, ch in enumerate(s):
if ch in minor_breaks:
segment = s[last+1:idx]
results.add(segment)
segment = s[:idx]
results.add(segment)
last = idx
segment = s[last+1:]
results.add(segment)
results.add(s)
return results
次要分割和主要分割的逻辑类似，只是还会把从开始部分到当前分割的结果加入。例如“1.2.3.4”的次要分割会有1，2，3，4，1.2，1.2.3
def segments(event):
"""Simple wrapper around major_segments / minor_segments"""
results = set()
for major in major_segments(event):
for minor in minor_segments(major):
results.add(minor)
return results
分词的逻辑就是对文本先进行主要分割，对每一个主要分割在进行次要分割。然后把所有分出来的词返回。
我们看看这段 code是如何运行的：
for term in segments('src_ip = 1.2.3.4'):
print term
好了，有个分词和布隆过滤器这两个利器的支撑后，我们就可以来实现搜索的功能了。
class Splunk(object):
def __init__(self):
self.bf = Bloomfilter(64)
self.terms = {}
self.events = []
def add_event(self, event):
"""Adds an event to this object"""
event_id = len(self.events)
self.events.append(event)
for term in segments(event):
self.bf.add_value(term)
if term not in self.terms:
self.terms[term] = set()
self.terms[term].add(event_id)
def search(self, term):
"""Search for a single term, and yield all the events that contain it"""
if not self.bf.might_contain(term):
if term not in self.terms:
for event_id in sorted(self.terms[term]):
yield self.events[event_id]
Splunk代表一个拥有搜索功能的索引集合每一个集合中包含一个布隆过滤器，一个倒排词表（字典），和一个存储所有事件的数组当一个事件被加入到索引的时候，会做以下的逻辑
为每一个事件生成一个unqie id，这里就是序号对事件进行分词，把每一个词加入到倒排词表，也就是每一个词对应的事件的id的映射结构，注意，一个词可能对应多个事件，所以倒排表的的值是一个Set。倒排表是绝大部分搜索引擎的核心功能。当一个词被搜索的时候，会做以下的逻辑
检查布隆过滤器，如果为假，直接返回检查词表，如果被搜索单词不在词表中，直接返回在倒排表中找到所有对应的事件id，然后返回事件的内容我们运行下看看把：
s = Splunk()
s.add_event('src_ip = 1.2.3.4')
s.add_event('src_ip = 5.6.7.8')
s.add_event('dst_ip = 1.2.3.4')
for event in s.search('1.2.3.4'):
print event
for event in s.search('src_ip'):
print event
for event in s.search('ip'):
print event
src_ip = 1.2.3.4
dst_ip = 1.2.3.4
src_ip = 1.2.3.4
src_ip = 5.6.7.8
src_ip = 1.2.3.4
src_ip = 5.6.7.8
dst_ip = 1.2.3.4
是不是很赞！
更复杂的搜索
更进一步，在搜索过程中，我们想用And和Or来实现更复杂的搜索逻辑。
class SplunkM(object):
def __init__(self):
self.bf = Bloomfilter(64)
self.terms = {}
self.events = []
def add_event(self, event):
"""Adds an event to this object"""
event_id = len(self.events)
self.events.append(event)
for term in segments(event):
self.bf.add_value(term)
if term not in self.terms:
self.terms[term] = set()
self.terms[term].add(event_id)
def search_all(self, terms):
"""Search for an AND of all terms"""
results = set(range(len(self.events)))
for term in terms:
if not self.bf.might_contain(term):
if term not in self.terms:
results = results.intersection(self.terms[term])
for event_id in sorted(results):
yield self.events[event_id]
def search_any(self, terms):
"""Search for an OR of all terms"""
results = set()
for term in terms:
if not self.bf.might_contain(term):
if term not in self.terms:
results = results.union(self.terms[term])
for event_id in sorted(results):
yield self.events[event_id]
利用Python集合的intersection和union操作，可以很方便的支持And（求交集）和Or（求合集）的操作。
运行结果如下：
s = SplunkM()
s.add_event('src_ip = 1.2.3.4')
s.add_event('src_ip = 5.6.7.8')
s.add_event('dst_ip = 1.2.3.4')
for event in s.search_all(['src_ip', '5.6']):
print event
for event in s.search_any(['src_ip', 'dst_ip']):
print event
src_ip = 5.6.7.8
src_ip = 1.2.3.4
src_ip = 5.6.7.8
dst_ip = 1.2.3.4
以上的代码只是为了说明大数据搜索的基本原理，包括布隆过滤器，分词和倒排表。如果大家真的想要利用这代码来实现真正的搜索功能，还差的太远。所有的内容来自于Splunk Conf2017。大家如果有兴趣可以去看网上的视频。
没有更多推荐了，}