使用Python爬虫和C++搭建离线IP库
发布时间：2023-08-16 12:00
夏季学期的专业实践被分配到了如标题所示的这个任务。在这里把完成这个任务的整个流程记录一下。
首先拿到了一个有一堆ipv4段的文件（提示无法安全下载可以复制到浏览器）：
总共有300多万个这样的IP段。最终的任务就是：给定一个IP地址，输出这个IP地址的信息（如国家、省份、城市、运营商）。
建立起IP段到其信息的对应关系
IP段总共有300多万个，为了保证效率我们只在每个IP段里取一个IP地址爬取其信息。先随便找到一个批量查询的网站（单个查询的实在是太慢了），我拿的是这个。首先分析一下这个网站爬取的格式：
可以看到这个结果在一个表格里：
HTTP请求方式是post，表单格式如下(F12-网络-在网页中再次提交一下表单)：
下面我们开始写爬虫部分的代码。如果python没有装requests库和BeautifulSoup需要装一下：
pip install bs4
pip install requests
函数原型:
import requests
from bs4 import BeautifulSoup
def IPBatchQuery(ipList):
pass
其中ipList为ipv4字符串的列表，至多200个。
首先用requests库来获得查询结果：
data = {'txt_ip': '\n'.join(ipList)}
response = requests.post('http://www.jsons.cn/ipbatch/', data = data)
然后利用BeautifulSoup库对html文本进行处理，我们发现网页里只有这一个表格：
因此我们直接查找tr的位置。
for tr in soup.find_all('tr'):
tds = tr.find_all('td')
info = []
# 对于表格的每列
for td in tds:
s = td.string # td.string获取表格内容
if not s == None:
info.append(s.strip()) # 以防万一去除前后的空格
if len(info) > 0: # 为0的是第一行(第一行是,没有信息被加入到info中)
lst.append(tuple(info))
return lst
整个函数如下:
def IPBatchQuery(ipList):
lst = []
if(len(ipList) > 200):
print('不能查询超过200个!')
return lst
data = {'txt_ip': '\n'.join(ipList)}
response = requests.post('http://www.jsons.cn/ipbatch/', data = data)
soup = BeautifulSoup(response.text, 'html.parser')
for tr in soup.find_all('tr'):
tds = tr.find_all('td')
info = []
for td in tds:
s = td.string
if not s == None:
info.append(s.strip())
if len(info) > 0: # 为0的是第一行
lst.append(tuple(info))
return lst
检验一下结果：
if __name__ == '__main__':
print(IPBatchQuery(['1.1.1.1', '1.3.4.5']))
应该没什么问题。当时在做的时候打算先把这些IP段的查询结果写入文本文件中，再写到数据库，毕竟之前没学过用python操作数据库，想把这两部分分离开。我把查询部分放到了服务器上，代码做了微调。此外在查询时（1）每5秒查询200条（防止查询太快把自己的IP封了，可持续发展）（2）每查询一次输出一下（3）需要先在目录下新建一个ipv4_data.txt，为了观察结果。服务器上的代码如下：
import time
import requests
from bs4 import BeautifulSoup
def IPBatchQuery(ipList):
lst = []
if(len(ipList) > 200):
print('不能查询超过200个!')
return
data = {'txt_ip': '\n'.join(ipList)}
response = requests.post('http://www.jsons.cn/ipbatch/', data = data)
f = open('txt.txt', 'w', encoding='utf-8')
soup = BeautifulSoup(response.text, 'html.parser')
for tr in soup.find_all('tr'):
tds = tr.find_all('td')
info = []
for td in tds:
s = td.string
if not s == None:
# 这里也调整了一下，为了防止有空的结果，用'XX'占一下位
if s.strip() == '':
info.append('XX')
else:
info.append(s.strip())
if len(info) > 0: # 为0的是第一行
lst.append(tuple(info))
return lst
ipv4_source = open('ipv4_source.txt', 'r')
# 先在目录下新建一个ipv4_data.txt，感觉w+和a+都不太方便
ipv4_data = open('ipv4_data.txt', 'r+', encoding='utf-8')
# 用来记录IP段源文件里的行数，忽略已经爬过的IP段
cnt = 0
# 已经存在的条数
lines = 0
# 这次爬的条数
output = 0
# IP列表，就是把IP段后面的掩码去掉的列表，如['1.1.0.0']
lst = []
# IP段的列表,如['1.1.0.0/16']
raw_lst = []
flag = False
# 获取一下之前爬的条数，从这里开始爬（防止爬的时候出现异常），顺便把文件指针指向最后
for line in ipv4_data:
if len(line.strip()) > 0:
lines += 1
# 打印一下有多少条
print('已经爬了' + str(lines) + '条')
for line in ipv4_source:
# 跳过已经查询过的IP段
if cnt < lines:
cnt += 1
continue
# 打印一下从哪个IP段开始爬
if flag == False:
flag = True
print('从' + line.strip() + '开始')
slash_pos = line.find('/')
ip = line[0:slash_pos]
lst.append(ip)
raw_lst.append(line)
output += 1
try:
# 攒够200条爬一次
if output%200 == 0:
result = IPBatchQuery(lst)
for i in range(200):
ipv4_data.write(raw_lst[i].strip() + ' ' + ' '.join(result[i]) + '\n')
lst = []
raw_lst = []
print('成功写入')
time.sleep(5)
except:
print(str(cnt) + '行处发生异常')
# 最后可能会不足200条，特殊处理一下
try:
if output > 0:
result = IPBatchQuery(lst)
for i in range(len(lst)):
ipv4_data.write(raw_lst[i].strip() + ' ' + ' '.join(result[i]) + '\n')
lst = []
except:
print('最后200条内发生了异常')
爬的时候应该是这样的：
txt文件：
最后的结果在这里。
把数据写入数据库
现在我们把文本文件写入MySQL数据库中。我首先写了一个操作数据库的工具类DBUtils备用(需要安装MySQL环境和python的MySQL库)：
pip install mysql-connector
下面这个文件在根目录下的./Utils/DBUtils下：
import mysql.connector
class DBUtils:
# 连接数据库
def __init__(self, host, usr, pwd):
self.host = host
self.usr = usr
self.pwd = pwd
self.db = mysql.connector.connect(host = host, user = usr, passwd = pwd, buffered = True)
# 检查数据库是否存在
def checkDB(self, name):
cursor = self.db.cursor()
cursor.execute('show databases')
for x in cursor:
if x[0] == name:
return True
return False
# 创建数据库
def createDB(self, name):
if(self.checkDB(name)):
print('数据库已存在')
return
self.execute('CREATE DATABASE ' + name)
print('已创建数据库' + name)
# 执行MySQL查询
def execute(self, sql):
cursor = self.db.cursor()
cursor.execute(sql)
return cursor
# 连接数据库
def connectDB(self, name):
self.db = mysql.connector.connect(host = self.host, user = self.usr, passwd = self.pwd, database = name, buffered = True)
print('已连接数据库' + name)
# 检查表是否存在
def checkTable(self, name):
cursor = self.db.cursor()
cursor.execute('show tables')
for table in cursor:
if table[0] == name:
return True
return False
# 提交修改
def commit(self):
self.db.commit()
然后我们把爬到的文件写入数据库：
创建数据库
from Utils.DBUtils import *
# 这里是自己数据库的账号和密码
db = DBUtils('localhost', 'username', 'password')
db.createDB('ip_info')
创建表
if not db.checkTable('ipv4'):
db.execute('''CREATE TABLE ipv4 (id int auto_increment primary key,
ipv4 varchar(20),
queried_country varchar(20), queried_province varchar(40), queried_city varchar(40),
queried_operator varchar(60))''')
创建的表有6列，分别是id、ipv4段、查询到的国家、省份、城市、运营商。
将数据写入数据库
cnt = 0
# 打开文件
f = open('ipv4_data.txt', 'r', encoding='utf-8')
for line in f:
# 用空格分隔
data = line.split(' ')
try:
db.execute(
'''INSERT INTO ipv4 (ipv4, queried_country, queried_province, queried_city, queried_operator)
VALUES (\'%s\', \'%s\', \'%s\', \'%s\', \'%s\')'''
% tuple(map(lambda x: x if x != 'XX' else '', data)))
except:
pass
cnt += 1
if cnt % 10000 == 0:
db.commit()
print('已写入%d条数据'%(cnt))
break
# 把最后的不足10000条部分也写入
db.commit()
tuple(map(lambda x: x if x != 'XX' else '', data))这一句是把查询结果中的XX变为空字符串，因为我们不希望数据库里出现XX这种信息。每10000条commit一次，如果不commit执行结果不会反应在数据库中。程序运行完应该是这样的：
给定IP查询其IP段
现在还差一步任务就能完成了：给定一个IP，我们需要知道它属于哪个IP段。根据最长匹配原则，我们必须遍历整个数据库，来找到一个IP所属的最小的子网。在这里我采用01字典树（01Trie）来实现这个匹配的过程，思想如下：对于每个IP段，如224.0.0.0/3,把它的公共部分（对于224.0.0.0/3即前3位，实际上不可能有这么大的IP段，举这个例子是方便说明）插入01Trie中。插入了两个IP段224.0.0.0/3和128.0.0.0/2的01Trie如下图（双边的圆圈表示终止节点，它代表了一个IP段）：
假如我们拿到了一个IP地址255.255.1.2，想要知道它属于哪个IP段。于是我们拿着这个IP从01Trie的根节点出发，顺着该IP的二进制往下走。由于255.255.1.2的前3位都是1，三步后就会走到224.0.0.0/3这个节点，它是一个终止节点，因此我们记录下来这个结果。然后我们发现不能继续往下走了，就直接返回224.0.0.0/3作为查询结果。当然，如果这棵树更大一点，我们在更深的地方可能会遇到更小的IP段，就要将更小的IP段作为查询结果了。（如，224.0.0.0/3下面还有一个255.255.0.0/16，就要返回255.255.0.0/16）
数据结构的实现
python这种语言实在不是太适合写数据结构，我就直接用C++来实现了。下面是数据结构的成员变量：
class IPTree {
private:
// 把unsigned int(32位)作为存储IP的数据类型。如果需要ipv6可以用__uint128_t之类的数据类型
typedef unsigned ipsize_t;
struct node {
bool final; // 标记该节点是否为终止节点(是否为一个IP段)
node* left;
node* right;
node() {
final = false;
this->left = nullptr;
this->right = nullptr;
}
node(bool final) {
this->final = final;
this->left = left;
this->right = right;
}
};
int IP_LENGTH;// IP的长度，ipv4为32,ipv6为128.这里我们只实现ipv4
node* root;// 根节点
std::ofstream output;// 用于保存结果的输出流，一会再说明
public:
IPTree() {
this->IP_LENGTH = 32;// 默认为ipv4，ipv6的道理也是一样的，不过会麻烦一些
root = new node();
}
};
下面再编写我们两个主要的方法insert(用于插入IP段)和query(用于查询一个ipv4所在的IP段)。
insert
void insert(std::string IP_segment) {
// 找到'/'的下标
int slash_pos = IP_segment.find('/');
//去掉后面的掩码位，如"/24"
std::string IP = IP_segment.substr(0, slash_pos);
//取得掩码的位数，如24
int mask = atoi(IP_segment.substr(slash_pos + 1).c_str());
//把该IP段转化为一个位向量，用于01Trie的插入
ipsize_t bits = ipv4_to_int(IP);
node* now = root;
for (int i = 1; i <= mask; i++) {
char bit = (bits >> (IP_LENGTH - i)) & 1;// 取出该位二进制
if (!bit) {//向左
if (now->left == nullptr) now->left = new node();
now = now->left;
}
else {//向右
if (now->right == nullptr) now->right = new node();
now = now->right;
}
}
//最后标记为终止节点
now->final = true;
}
中间用到了一个辅助函数ipv4_to_int,用于把ipv4地址(string类型)转化为位向量(其实就是unsigned类型)，代码如下：
//例：给定ipv4="255.128.0.1",
//返回的unsigned数据类型二进制表示为:
//1111 1111 1000 0000 0000 0000 0000 0001
ipsize_t ipv4_to_int(std::string ipv4) {
ipsize_t ret = 0;
char *p = new char[20], *ip = new char[20];
strcpy(ip, ipv4.c_str());
//获取每一节(类似于Java String.split)
p = strtok(ip, ".");
int i = 3;
while (p) {
ret |= atoi(p) << (8 * i--);
p = strtok(NULL, ".");
}
return ret;
}
query
这个函数给定一个string类型的ipv4地址，返回其ip段。
std::string query(std::string IP) {
ipsize_t bits = ipv4_to_int(IP);
int i = 0, depth = 0, mask = 0;
node* now = root;
while (now != nullptr) {
char bit = (bits >> (IP_LENGTH - (++i))) & 1;// 取出该位二进制
//当前位为1向右走，否则向左走
now = bit ? now->right : now->left;
// 如果当前节点是一个终止节点，就记录一下最长的掩码位数(如24)
if (now && now->final) {
mask = i;
}
}
//没有查询到
if (!mask) return "";
bits &= (ipsize_t)(~0) << (IP_LENGTH - mask);// 把右边清成0。这里用到了一些简单的位运算性质
//再把bits转换成ipv4/ipv6格式
return int_to_ipv4(bits) + "/" + std::to_string(mask);
}
最后也有一个辅助函数int_to_ipv4,是把一个位向量转化为ipv4的点分十进制字符串格式。
std::string int_to_ipv4(ipsize_t ipv4) {
std::string ret;
for (int i = 3; i >= 0; i--) {
unsigned char val = (ipv4 >> (i * 8)) & 0xFF;
ret += std::to_string(val) + ((i == 0) ? "" : ".");
}
return ret;
}
对数据进行保存、读取
我们再给这个IPTree数据结构增加两个用于读写的方法，来实现对IP段相关数据的存档。首先我们考虑保存问题：我们要做的就是把一棵01Trie一一映射到一个字符串，把这个字符串保存到文本文件里，以供下次使用。我们很自然地想到利用先序遍历，来生成一个唯一的字符串：
private:
//先序遍历
void dfs_write(node* now) {
if (now == nullptr) {
output << '#';
return;
}
else {
output << (int)now->final;
}
dfs_write(now->left);
dfs_write(now->right);
}
public:
void write(std::string file) {
output.open(file);
dfs_write(root);
}
其中output是一个输出流，在上面的成员变量部分提到过。这种先序遍历的方式能保证字符串和二叉树的一一对应，比如下图：
这棵二叉树对应的字符串就是"0#01##0#1##"。我们可以再按照相同的规则把这个字符串转化为二叉树：
private:
node* dfs_read(FILE* file) {
char ch = fgetc(file);
node* now = nullptr;
if (ch == '0') {
now = new node(false);
}
else if (ch == '1') {
now = new node(true);
}
else return now; // 是#
now->left = dfs_read(file);
now->right = dfs_read(file);
return now;
}
public:
void read(std::string file) {
FILE* f = fopen(file.c_str(), "r");
root = dfs_read(f);
}
整个IPTree.h如下：
#pragma once
#include
之后，我们就可以通过如下的调用来初始化01Trie：
int main() {
IPTree ipt;
std::string ips;
std::ifstream input;
//ipv4_source是最开始给定的那个文件
input.open("ipv4_source.txt");
while(input >> ips) {
ipt.insert(ips);
}
//把数据写入data.txt中
ipt.write("data.txt");
}
data.txt应该是长这个样子的（这个相比原始的数据大小压缩了77%）：
得到data.txt后，我们就可以通过读取这个文件来初始化了：
int main() {
IPTree ipt;
ipt.read("data.txt");
std::cout << ipt.query("1.2.3.4");
}
可以看到查询得到了1.2.3.4这个IP所在的IP段。
综合一下
我们的主要功能部分已经大部分实现了，下面只需要把它们拼装一下留出来一个查询接口就可以了。由于我们的01Trie采用C++实现，我们最终的查询接口最好也是C++的。为此我们还需要配置一下C++的MySQL环境，可以参见这篇博客（Visual Studio下）。
我们新建一个IPQueryManager类：
//下面两个为调用mysql必要的头文件(windows下)
#include
下面完成最后的接口：
std::string IPQuery(std::string ipv4) {
std::string ret;
std::string q = "select * from ipv4 where ipv4=\'" + ipt.query(ipv4) + "\'";
if (mysql_real_query(&mysql, q.c_str(), (unsigned long)strlen(q.c_str()))) {
std::cout << "Query failure!" << std::endl;
return "";
}
MYSQL_RES* res = mysql_store_result(&mysql);
if (res == NULL) {
std::cout << "MySQL restore failure!" << std::endl;
return "";
}
while (row = mysql_fetch_row(res)) {
for (int i = 2; i <= 5; i++) {
std::string str;
if (row[i] != NULL) {
str = row[i];
ret += str + ((i == 5) ? "" : ",");
}
else str = "";
}
}
return ret;
}
运行一下试试:
int main()
{
// 改成自己的数据库信息
IPQueryManager ipqm("localhost", "username", "password", "ip_info");
std::cout << ipqm.IPQuery_true("1.0.4.0");
}
