用python抓取oj题目（2）——Sqlalchemy将数据存到数据库

　　上一篇 用BS分析好界面元素之后，将我们需要的信息放到一个info的list里面给返回来出来，方便期间，info包括这些东西
##        """ return 12 infos
##        1.title 2.limit des 3.problem des 4.input 5.output
##        6.sample input 7.sample output 8.hint 9.author
##        10.source 11.recommend 12.imgages
##        the last element is a list of images """

　　info的最后一个元素是一个图片的list。
　　现在那，有了这些个信息，就需要把他们存到数据库里了。额，想了一下，图片的地址就不存来，直接把图片下来，然后通过html来引用就好了。所以，需要记录info里面的前11条信息，以及1个题号。
　　先上代码（需要导入的东西忘了粘了from sqlalchemy import *        from sqlalchemy.orm import * ）：
 1 def store(start, end, url=''):
 2     engine = create_engine("mysql://root:duoduo@localhost:3306/test?charset=utf8", encoding="utf-8", echo=True)
 3     metadata = MetaData()
 4     hdoj_table = Table('hdoj', metadata,
 5             Column('problem_id', Integer, primary_key=True),
 6             Column('title', String(255), nullable=False),
 7             Column('limit_description', String(255), nullable=False),
 8             Column('problem_description', Text, nullable=False),
 9             Column('input', Text, nullable=False),
10             Column('output', Text, nullable=False),
11             Column('sample_input', Text, nullable=False),
12             Column('sample_output', Text, nullable=False),
13             Column('hint', Text, nullable=True),
14             Column('author', String(40), nullable=True),
15             Column('source', Text, nullable=True),
16             Column('recommend', String(255), nullable=True),
17             )
18
19     class Hdoj(object):
20         def __init__(self, problem_id, title, limit_description, problem_description, input, output, sample_input, sample_output, hint, author, source, recommend):                       
21             self.problem_id = problem_id
22             self.title = title
23             self.limit_description = limit_description
24             self.problem_description = problem_description
25             self.input = input
26             self.output = output
27             self.sample_input = sample_input
28             self.sample_output = sample_output
29             self.hint = hint
30             self.author = author
31             self.source = source
32             self.recommend = recommend
33        
34         def __repr__(self):
35             return "" % (self, title)
36    
37     metadata.create_all(engine)
38    
39     mapper(Hdoj, hdoj_table)
40    
41     Session = sessionmaker(autoflush=True, bind=engine)
42    
43     session = Session()
44    
45     data = []
46     images = []
47     for i in range(start, end):
48         problem_id = str(i)
49         info = catch(url + problem_id)
50         if info[2] == 'None':
51             continue
52         data.append(Hdoj(problem_id, info[0], info[1], info[2], info[3], info[4], info[5], info[6], info[7], info[8], info[9], info[10]))
53         images.append(info[-1])
54        
55            
56     length = len(data)
57     for i in range(length):
58         try:
59             session.add(data[i])
60             session.flush()
61             print 'adding'
62         except Exception as e:
63             #print 'exception'
64             #print e
65             session.rollback()
66             pass
67     return images
 

　　解释：
 1 def store(start, end, url=''):
　　　　start和end是开始到结束的题号，例如我想把1000～2000题都给存下来，那么就store（1000，2000）就好了，url就是之前分析过的默认题目前缀。

 2     engine = create_engine("mysql://root:123@localhost:3306/test?charset=utf8", encoding="utf-8", echo=True)
　　　　sqlalchemy里面的，sqlalchemy那就像是一个抽象出来的基类一样的东西，你只需要建立一个数据库的引擎，然后就可以在这个数据库上操作，具体的数据库的一些建表插入操作都不用你来操心了，非常方便。例如，我这个引擎是的，用户名为root，密码123，字符集utf8，echo是为了显示一下sqlalchemy到底干了什么，所以设定为True，当然正式发布的时候需要改成False。
 1     metadata = MetaData()
 2     hdoj_table = Table('hdoj', metadata,
 3             Column('problem_id', Integer, primary_key=True),
 4             Column('title', String(255), nullable=False),
 5             Column('limit_description', String(255), nullable=False),
 6             Column('problem_description', Text, nullable=False),
 7             Column('input', Text, nullable=False),
 8             Column('output', Text, nullable=False),
 9             Column('sample_input', Text, nullable=False),
10             Column('sample_output', Text, nullable=False),
11             Column('hint', Text, nullable=True),
12             Column('author', String(40), nullable=True),
13             Column('source', Text, nullable=True),
14             Column('recommend', String(255), nullable=True),
15             )

　　metadata是神马我不是很了解，（元数据？？），总之先记下来用着，然后就是新建一个表，每个oj一张表，所以，就有了上面这2～15行，单词描述的比较明显，不解释了就。
 1 class Hdoj(object):
 2         def __init__(self, problem_id, title, limit_description, problem_description, input, output, sample_input, sample_output, hint, author, source, recommend):                       
 3             self.problem_id = problem_id
 4             self.title = title
 5             self.limit_description = limit_description
 6             self.problem_description = problem_description
 7             self.input = input
 8             self.output = output
 9             self.sample_input = sample_input
10             self.sample_output = sample_output
11             self.hint = hint
12             self.author = author
13             self.source = source
14             self.recommend = recommend
15        
16         def __repr__(self):
17             return "" % (self, title)
18    
19     metadata.create_all(engine)
20    
21     mapper(Hdoj, hdoj_table)

　　接下来新建一个Hdoj的类，并且讲这个类与刚刚建的数据表做好映射。
　　1～14行就是Hdoj了
　　19、20行里面，是sqlalchemy的东西了，19行是真正的建立引擎，20行是将类与的数据库的表做映射。
　　接下来是存储：
 1     Session = sessionmaker(autoflush=True, bind=engine)
 2    
 3     session = Session()
 4    
 5     data = []
 6     images = []
 7     for i in range(start, end):
 8         problem_id = str(i)
 9         info = catch(url + problem_id)
10         if info[2] == 'None':
11             continue
12         data.append(Hdoj(problem_id, info[0], info[1], info[2], info[3], info[4], info[5], info[6], info[7], info[8], info[9], info[10]))
13         images.append(info[-1])
14        
15            
16     length = len(data)
17     for i in range(length):
18         try:
19             session.add(data[i])
20             session.flush()
21             print 'adding'
22         except Exception as e:
23             #print 'exception'
24             #print e
25             session.rollback()
26             pass
27     return images
 

　　session这个东西，个人的理解就是一次链接，在这儿一个session就是python和数据库的一次链接，然后我们对这个session进行一系列操作，存储啊添加啊神马的，注意，只要session没有flush（），操作都是在缓存里面进行的，查文档发现commit（）是提交的一个函数，它里面是会调用flush（）的。
 1     Session = sessionmaker(autoflush=True, bind=engine) 
 　　用sessionmaker建立一个Session，绑定了之前建立的引擎。
 3     session = Session() 　　
　　建立一个Session（你用sessionmaker建立的特殊的一个链接）的对象。
　　5～13都是添加对象
 8         problem_id = str(i) 
 9         info = catch(url + problem_id)
　　用之前写好的catch函数抓取需要的信息，存到info里面，注意url变了，这样来进行题目的遍历。
10         if info[2] == 'None':
11             continue
　　这两行是防止神马的，防止数据库加入没有的题目，比如杭电的题目就到4186，如果store（10000，10010），会把着些没有的url给存到数据库里面，这不是我们想要的，如果没有这个题目的话，让他默默的失败，进行下一个链接。
　
 5     data = []
 6     images = []　
12         data.append(Hdoj(problem_id, info[0], info[1], info[2], info[3], info[4], info[5], info[6], info[7], info[8], info[9], info[10]))
13         images.append(info[-1])
　　data是我真正想存到数据库里面的信息，images则是不想存到里面的图片信息，分开分开。
 1     length = len(data)
 2     for i in range(length):
 3         try:
 4             session.add(data[i])
 5             session.flush()
 6             print 'adding'
 7         except Exception as e:
 8             #print 'exception'
 9             #print e
10             session.rollback()
11             pass
12     return images
 

　　这几行是最重要，这是真正把数据放到数据库里的。
　　首先要说明为什马要用异常，我的主键用的是题号啊，第一次store（1000，1120）的时候一般是不会错的，如果第二次我想store（1100，1200）,数据库会告诉我主键重复，不能添加，额，这个当时纠结了好久，各种查，无果，学长告诉我说你可以抓异常啊，弱弱的说一句，我这还真是第一次用异常，没想到介么好用、、
　　然后是rollback（），rollback像他的名字一样，回滚。session在进行一次链接的时候，每条数据和数据库链接在一起，直到等到rollback它才进行下一条数据的链接（这都是我自己感觉的，如果不对啊话@我下下，学习中），额、怎么说那，举个例子吧，如果说我存store（1055，1070），在1056题，4行添加数据，5行想要更新缓存，写入数据库的时候出现异常了，假设没有rollback这个函数，仅仅是pass的话，session着个叫做链接的东西依然把python和数据库里面的1056进行链接，而不会向下走，结果就是下面的14条数据继续异常，而且给的异常都是第1056题目的主键重复，就是说在循环继续后，数据库并没有断开和1056题的链接，依然尝试把1056题的数据加进来。（这些是真的啊，就不回去实验截图了，一会儿还要上课）
　　信息要一条一条的存，包不准那一条就会有异常。虽然说session有个addAll()函数，但是如果里面有一条数据出了异常，如果用我第10行的处理机制，那么那一条异常数据后面的所有数据全部都不能添加了。
　　由于不想把图片存到数据库里面，把它直接return出去了，新写一个函数把图片存到本地。
　　就是用python处理文件的那一套，代码：
 1 def download_img(url, default_url_head='http://acm.hdu.edu.cn/data/images/', default_file_head='/home/duoduo/images/', pro_file_head='hdoj'):
 2     filename = url.split('/')[-1]
 3     url_head = default_url_head
 4     file_head = default_file_head
 5    
 6     url_path = url_head + filename
 7     #print url_path
 8     file_path = file_head + pro_file_head + '/' + filename
 9     #print file_path
10     try:
11         open_img = urllib2.urlopen(url_path)
12         img = open_img.read()
13         img_file = open(file_path, 'wb')
14         img_file.write(img)
15         img_file.close()
16         print 'downloading images from:' + url_path
17     except:
18         print 'HTTP Error 404: Not Found'
19         pass

　　第2～9行就是把url和本地的路径进行一些处理
　　10～19行下载，依然要抓异常，因为有些图本身就挂了，打不开，会弹出404异常
　　13～15就是文件的读写操作，把图片信息存起来来。
　　
　　存储就到这里了，然后包一下，做一个start函数，把上面的东西都给装进来：
 1 def start(begin, end):
 2     if(end < begin):
 3         print '输入有误，请检查您的输入。'
 4         return None
 5
 6     default_group_num = 50
 7     groups = (end - begin) / default_group_num
 8    
 9     for i in range(groups):
10         group_start = i * default_group_num + begin
11         group_end = (i + 1) * default_group_num + begin
12         images_list = store(group_start, group_end)
13         len_img_list = len(images_list)
14         for i in range(len_img_list):                       
15             len_img = len(images_list[i])
16             for j in range(len_img):                   
17                 download_img(images_list[i][j])
18
19     if (end - begin) >= 0 :
20         last_group_start = groups * default_group_num + begin
21         images_list = store(last_group_start, end + 1)
22         len_img_list = len(images_list)
23         for i in range(len_img_list):                       
24             len_img = len(images_list[i])
25             for j in range(len_img):                   
26                 download_img(images_list[i][j])

 6     default_group_num = 50
　　默认一次存多少数据，我怕一次存太多，内存受不了，或者是等了10来分钟结果中途崩了，还要从头来，麻烦。
 7     groups = (end - begin) / default_group_num
　　groups以及一下的for循环就是做分组处理的。
　　python抓数据，存数据就彻底ok了，下一步就是用django显示看看是否正确，django的静态文件这次是深刻体会了，上课去先，晚上或者明天在写下一篇吧。