看到网上也有开源的代码，这不，我拿来进行了二次重写，呵呵，上代码：

复制代码 代码如下:

#encoding: utf-8    
import socket    
from hashlib import sha1    
from random import randint    
from struct import unpack, pack    
from socket import inet_aton, inet_ntoa    
from bisect import bisect_left    
from threading import Timer    
from time import sleep    
import MySQLdb    
from datetime import *    
import time    
from bencode import bencode, bdecode    
BOOTSTRAP_NODES = [    
    ("router.bittorrent.com", 6881),    
    ("dht.transmissionbt.com", 6881),    
    ("router.utorrent.com", 6881)    
]     
TID_LENGTH = 4    
KRPC_TIMEOUT = 10    
REBORN_TIME = 5 * 60    
K = 8    
def entropy(bytes):    
    s = ""    
    for i in range(bytes):    
        s += chr(randint(0, 255))    
    return s    
def random_id():    
    hash = sha1()    
    hash.update( entropy(20) )    
    return hash.digest()    
def decode_nodes(nodes):    
    n = []    
    length = len(nodes)    
    if (length % 26) != 0:     
        return n    
    for i in range(0, length, 26):    
        nid = nodes[i:i+20]    
        ip = inet_ntoa(nodes[i+20:i+24])    
        port = unpack("!H", nodes[i+24:i+26])[0]    
        n.append( (nid, ip, port) )    
    return n    
def encode_nodes(nodes):    
    strings = []    
    for node in nodes:    
        s = "%s%s%s" % (node.nid, inet_aton(node.ip), pack("!H", node.port))    
        strings.append(s)    
    return "".join(strings)    
def intify(hstr):    
    return long(hstr.encode('hex'), 16)        
def timer(t, f):    
    Timer(t, f).start()    
class BucketFull(Exception):    
    pass    
class KRPC(object):    
    def __init__(self):    
        self.types = {    
            "r": self.response_received,    
            "q": self.query_received    
        }    
        self.actions = {    
            "ping": self.ping_received,    
            "find_node": self.find_node_received,    
            "get_peers": self.get_peers_received,    
            "announce_peer": self.announce_peer_received,    
        }    
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)    
        self.socket.bind(("0.0.0.0", self.port))    
    def response_received(self, msg, address):    
        self.find_node_handler(msg)    
    def query_received(self, msg, address):    
        try:    
            self.actions[msg["q"]](msg, address)    
        except KeyError:    
            pass    
    def send_krpc(self, msg, address):    
        try:    
            self.socket.sendto(bencode(msg), address)    
        except:    
            pass    
class Client(KRPC):    
    def __init__(self, table):    
        self.table = table    
        timer(KRPC_TIMEOUT, self.timeout)    
        timer(REBORN_TIME, self.reborn)    
        KRPC.__init__(self)    
    def find_node(self, address, nid=None):    
        nid = self.get_neighbor(nid) if nid else self.table.nid    
        tid = entropy(TID_LENGTH)    
        msg = {    
            "t": tid,    
            "y": "q",    
            "q": "find_node",    
            "a": {"id": nid, "target": random_id()}    
        }    
        self.send_krpc(msg, address)    
    def find_node_handler(self, msg):    
        try:    
            nodes = decode_nodes(msg["r"]["nodes"])    
            for node in nodes:    
                (nid, ip, port) = node    
                if len(nid) != 20: continue    
                if nid == self.table.nid: continue    
                self.find_node( (ip, port), nid )    
        except KeyError:    
            pass    
    def joinDHT(self):    
        for address in BOOTSTRAP_NODES:     
            self.find_node(address)    
    def timeout(self):    
        if len( self.table.buckets ) < 2:    
            self.joinDHT()    
        timer(KRPC_TIMEOUT, self.timeout)    
    def reborn(self):    
        self.table.nid = random_id()    
        self.table.buckets = [ KBucket(0, 2**160) ]    
        timer(REBORN_TIME, self.reborn)    
    def start(self):    
        self.joinDHT()    
        while True:    
            try:    
                (data, address) = self.socket.recvfrom(65536)    
                msg = bdecode(data)    
                self.types[msg["y"]](msg, address)    
            except Exception:    
                pass    
    def get_neighbor(self, target):    
        return target[:10]+random_id()[10:]    
class Server(Client):    
    def __init__(self, master, table, port):    
        self.table = table    
        self.master = master    
        self.port = port    
        Client.__init__(self, table)    
    def ping_received(self, msg, address):    
        try:    
            nid = msg["a"]["id"]    
            msg = {    
                "t": msg["t"],    
                "y": "r",    
                "r": {"id": self.get_neighbor(nid)}    
            }    
            self.send_krpc(msg, address)    
            self.find_node(address, nid)    
        except KeyError:    
            pass    
    def find_node_received(self, msg, address):    
        try:    
            target = msg["a"]["target"]    
            neighbors = self.table.get_neighbors(target)    
            nid = msg["a"]["id"]    
            msg = {    
                "t": msg["t"],    
                "y": "r",    
                "r": {    
                    "id": self.get_neighbor(target),     
                    "nodes": encode_nodes(neighbors)    
                }    
            }    
            self.table.append(KNode(nid, *address))    
            self.send_krpc(msg, address)    
            self.find_node(address, nid)    
        except KeyError:    
            pass    
    def get_peers_received(self, msg, address):    
        try:    
            infohash = msg["a"]["info_hash"]    
            neighbors = self.table.get_neighbors(infohash)    
            nid = msg["a"]["id"]    
            msg = {    
                "t": msg["t"],    
                "y": "r",    
                "r": {    
                    "id": self.get_neighbor(infohash),     
                    "nodes": encode_nodes(neighbors)    
                }    
            }    
            self.table.append(KNode(nid, *address))    
            self.send_krpc(msg, address)    
            self.master.log(infohash)    
            self.find_node(address, nid)    
        except KeyError:    
            pass    
    def announce_peer_received(self, msg, address):    
        try:    
            infohash = msg["a"]["info_hash"]    
            nid = msg["a"]["id"]    
            msg = {     
                "t": msg["t"],    
                "y": "r",    
                "r": {"id": self.get_neighbor(infohash)}    
            }    
            self.table.append(KNode(nid, *address))    
            self.send_krpc(msg, address)    
            self.master.log(infohash)    
            self.find_node(address, nid)    
        except KeyError:    
            pass    
class KTable(object):    
    def __init__(self, nid):    
        self.nid = nid    
        self.buckets = [ KBucket(0, 2**160) ]    
    def append(self, node):    
        index = self.bucket_index(node.nid)    
        try:    
            bucket = self.buckets[index]    
            bucket.append(node)    
        except IndexError:    
            return    
        except BucketFull:    
            if not bucket.in_range(self.nid): return    
            self.split_bucket(index)    
            self.append(node)    
    def get_neighbors(self, target):    
        nodes = []    
        if len(self.buckets) == 0: return nodes    
        if len(target) != 20 : return nodes    
        index = self.bucket_index(target)    
        try:    
            nodes = self.buckets[index].nodes    
            min = index - 1    
            max = index + 1    
            while len(nodes) < K and ((min >= 0) or (max < len(self.buckets))):    
                if min >= 0:    
                    nodes.extend(self.buckets[min].nodes)    
                if max < len(self.buckets):    
                    nodes.extend(self.buckets[max].nodes)    
                min -= 1    
                max += 1    
            num = intify(target)    
            nodes.sort(lambda a, b, num=num: cmp(num^intify(a.nid), num^intify(b.nid)))    
            return nodes[:K]    
        except IndexError:    
            return nodes    
    def bucket_index(self, target):    
        return bisect_left(self.buckets, intify(target))    
    def split_bucket(self, index):    
        old = self.buckets[index]    
        point = old.max - (old.max - old.min)/2    
        new = KBucket(point, old.max)    
        old.max = point    
        self.buckets.insert(index + 1, new)    
        for node in old.nodes[:]:    
            if new.in_range(node.nid):    
                new.append(node)    
                old.remove(node)    
    def __iter__(self):    
        for bucket in self.buckets:    
            yield bucket    
class KBucket(object):    
    __slots__ = ("min", "max", "nodes")    
    def __init__(self, min, max):    
        self.min = min    
        self.max = max    
        self.nodes = []    
    def append(self, node):    
        if node in self:    
            self.remove(node)    
            self.nodes.append(node)    
        else:    
            if len(self) < K:    
                self.nodes.append(node)    
            else:    
                raise BucketFull    
    def remove(self, node):    
        self.nodes.remove(node)    
    def in_range(self, target):    
        return self.min <= intify(target) < self.max    
    def __len__(self):    
        return len(self.nodes)    
    def __contains__(self, node):    
        return node in self.nodes    
    def __iter__(self):    
        for node in self.nodes:    
            yield node    
    def __lt__(self, target):    
        return self.max <= target    
class KNode(object):    
    __slots__ = ("nid", "ip", "port")    
    def __init__(self, nid, ip, port):    
        self.nid = nid    
        self.ip = ip    
        self.port = port    
    def __eq__(self, other):    
        return self.nid == other.nid    
#using example    
class Master(object):    
    def __init__(self, f):    
        self.f = f    
        try:    
            self.conn=MySQLdb.connect(host='localhost',user='root',passwd='',db='bt',port=3306)    
            self.cur=self.conn.cursor()    
        except MySQLdb.Error,e:    
            print "Mysql Error %d: %s" % (e.args[0], e.args[1])    
    def log(self, infohash):    
        try:    
            sql = "insert into bt_main_new(hash,name,length,date) values(%s,%s,%s,%s)"    
            date = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())    
            re=self.cur.execute(sql,(infohash,'','',date))    
            self.conn.commit()    
            self.cur.close()    
            self.conn.close()    
            #print re    
        except MySQLdb.Error,e:    
            print "Mysql Error %d: %s" % (e.args[0], e.args[1])    
        self.f.write(infohash.encode("hex")+"\n")    
        self.f.flush()    
try:    
    d = date.today()    
    f = open("%s.log" % d, "a")    
    m = Master(f)    
    s = Server(Master(f), KTable(random_id()), 8006)    
    s.start()         
except KeyboardInterrupt:    
    s.socket.close()    
    f.close()    

本爬虫程序，会自动爬取得网络上分享的bt种子，写入文件盒数据库，爬取的只是个种子的hash码，还需要到网络上下载种子进行分析

下载种子，相信大家都知道国外有几个免费分享种子的网站，大家可以根据hash码去下载，分析，下面呈上我写的一个分析种子的程序：

复制代码 代码如下:

! /usr/bin/python

-- coding: utf-8 --

import MySQLdb
from datetime import
import time
import re
from time import sleep
import bencode
import urllib2
import base64
try:
conn=MySQLdb.connect(host='localhost',user='root',passwd='',db='bt',port=3306)
cur=conn.cursor()
sql = "select from bt_main where name = '' order by id desc"
count = cur.execute(sql)
rows = cur.fetchall()
for row in rows:
if row[2].strip() != '':
continue
id = row[0]
hash = row[1]
url = "http://haofuli.duapp.com/go/info.php?hash=%s" % hash
file = urllib2.urlopen(url).read()
if "error!" == file:
try:
sql = "update bt_main set isTrue = 0 where id = %s "
re = cur.execute(sql,(id))
conn.commit()
except MySQLdb.Error,e:
print "Mysql Error %d: %s" % (e.args[0], e.args[1])
else:

decode

        try:    
            fileEncode = bencode.bdecode(file)    
        except Exception,e:pass    
        if 'name.utf-8' in fileEncode['info']:    
            filename=fileEncode['info']['name.utf-8']    
        else:    
            filename = fileEncode['info']['name']    
        ##length    
        if "length" in fileEncode['info']:    
            length = fileEncode['info']['length']    
        else:    
            length = 0    
        try:    
            sql = "update bt_main set name = %s , length = %s , isTrue = 1 where id = %s"    
            re = cur.execute(sql,(base64.b64encode(filename),length,id))    
            conn.commit()    
        except MySQLdb.Error,e:    
            print "Mysql Error %d: %s" % (e.args[0], e.args[1])    

except MySQLdb.Error,e:
print "Mysql Error %d: %s" % (e.args[0], e.args[1])

上面的只是简单的分析，对于多文件的，还没有处理。我最近在解析种子的时候，总是出现莫名的填充文件的问题，可能是版本过低吧，最近仍旧在解决。