通过python urllib和urllib2在本地主机上的HTTP请求非常慢

我使用urllib和urllib2编写了一个简单的类来发送http请求并获取响应。但是，使用其IP地址向localhost发出的任何请求都非常慢

本地主机的IP地址为=192.168.158.27

import urllib2,urllib,re,datetime,time

class HTTPRequest():
    def __init__(self,**kargs):
        self._response = None
        self._buffer = None
        self._conn = urllib2.build_opener(urllib2.HTTPCookieProcessor())
        urllib2.install_opener(self._conn)

    def _encode_url(self,**kargs):
        try:
            params = urllib.urlencode(kargs)
        except:
            raise HTTPError("Failed to encode URL parameters..")

        return str(params)

    def _request(self,url=None,params=None):
        try:
            self._buffer = self._conn.open(url,params)
            self._response = self._buffer.read()
        except ValueError:
             raise HTTPError("Invalid URL %s" % url)
        except:
            raise HTTPError("Failed to send HTTP(s) Request")
        return str(self._response)

class HTTPError(Exception):
    pass


PARAM_PASSWORD = 'password'
PARAM_USER = 'userName'
PARAM_ACTION = 'a'
PARAM_RID = 'rid'
PARAM_XO = 'xo'
PARAM_START_TIME = 't1'
PARAM_END_TIME = 't2'
PARAM_PATH = 'path'

BOOLEAN_TRUE = 'true'
BOOLEAN_FALSE = 'false'

ACTION_SIGNIN = 'signIn'
ACTION_SEARCH = 'search'
ACTION_GET_NEXT_RESULTS = 'getNextResults'

STATUS_SUCCEEDED = 'succeeded'

DEFAULT_WAIT = 5

host = "192.168.158.27"
user = "admin"
password = "admin"
protocol = "https"
port = 8443
query = "vm[=name rx (?i) *]&[@cpuUsage rx b .+][@cpuUsagemhz rx b .+]"
start_time = "10/05/2013 16:16:00"
end_time = "10/05/2013 17:16:00"
base_url = "%s://%s:%d" % (protocol,host,port)
login_url = "%s/user" % base_url

http = HTTPRequest()

attributes = {PARAM_PASSWORD : password,
              PARAM_USER : user,
              PARAM_ACTION : ACTION_SIGNIN,
              PARAM_RID : 1000,
              PARAM_XO : BOOLEAN_TRUE}

params = http._encode_url(**attributes)

if not http._request(login_url,params):
        print "Login Failed.."

else:
        print "Login Successful.. \n"



rid = 1000

search_url = "%s/Search" % base_url

status = STATUS_SUCCEEDED
hasMoreData = BOOLEAN_TRUE
completed = BOOLEAN_FALSE
total = 0
processed = 1
responseContent = ""
xml_dict = {}
_response = ""

attributes = {PARAM_START_TIME : start_time,
              PARAM_END_TIME : end_time,
              PARAM_ACTION : ACTION_SEARCH,
              PARAM_RID : rid,
              PARAM_PATH : query}

print "URL PARAMETERS :"
print "\tBase url = %s" % base_url

for param in attributes:
    print "\t%s = %s" % (param,attributes[param])

#Query Execution Start Time
start = datetime.datetime.now()

while True:
    params = http._encode_url(**attributes)
    if hasMoreData == BOOLEAN_TRUE:
        #Delay 10ms
        time.sleep(10/1000)

        #Send HTTP Request
        response = http._request(search_url,params)

        pattern = re.match(".*?hasMoreData=\"(.*?)\".*?",response)
        if pattern:
            hasMoreData = pattern.group(1)

        pattern = re.match(".*?status=\"(.*?)\".*?",response)
        if pattern:
            status = pattern.group(1)

        pattern = re.match(".*?completed=\"(.*?)\".*?",response)
        if pattern:
            completed = pattern.group(1)

        pattern = re.match(".*?processed=\"(.*?)\".*?",response)
        if pattern:
            processed = pattern.group(1)

        pattern = re.match(".*?total=\"(.*?)\".*?",response)
        if pattern:
            total = pattern.group(1)

        pattern = re.match(".*?matched=\"(.*?)\".*?",response)
        if pattern:
            matched = pattern.group(1)

        attributes = {PARAM_ACTION : ACTION_GET_NEXT_RESULTS,
                      PARAM_RID : rid}

        if matched != "0":
            response = re.sub(r'\n',"",response)
            matchObj = re.search(r'(<Resource.*</Resource>)',response)

            resp_match = ""
            if matchObj:
                resp_match = matchObj.group(1)

            responseContent = str(responseContent) + str(resp_match)
    else:
        #Query Execution Completed
        #Query Execution End Time
        end = datetime.datetime.now()

        print "RESULTS : "
        print "\tStatus = %s"%status
        print "\tHas More Data = %s"%hasMoreData
        print "\tCompleted = %s"%completed
        print "\tProcessed = %s"%processed
        print "\tTotal = %s"%total
        print "\tMatched = %s"%matched
        print "\nQuery Execution Started : %s" % start
        print "Query Execution Ended   : %s\n" % end

        if total != processed:
            err = "The number records processed did not match"
            err += " with the number of records completed."
            print err

        if not status == STATUS_SUCCEEDED:
            err = "The responce status is not 'succeeded'"
            print err

        if completed == BOOLEAN_FALSE:
            err = "The repsponse is completed. "
            err += "However, the flag is set to 'False'"
            print err
        break

导入urllib2、urllib、re、日期时间、时间
类HTTPRequest（）：
定义初始（自我，**kargs）：
自响应=无
自身缓冲区=无
self.\u conn=urllib2.build\u opener（urllib2.HTTPCookieProcessor（））
urllib2.安装开启器（自连接）
定义编码url（自我，**kargs）：
尝试：
params=urllib.urlencode（kargs）
除：
raise HTTPError（“未能编码URL参数…”）
返回str（params）
def_请求（self，url=None，params=None）：
尝试：
self.\u buffer=self.\u conn.open（url，参数）
self.\u response=self.\u buffer.read（）
除值错误外：
引发HTTPError（“无效的URL%s”%URL）
除：
raise HTTPError（“发送HTTP（s）请求失败”）
返回str（自我应答）
类HTTPError（异常）：
通过
PARAM_PASSWORD='PASSWORD'
PARAM_USER='userName'
参数动作='a'
PARAM_RID='RID'
参数XO='XO'
参数开始时间='t1'
参数结束时间='t2'
参数路径='PATH'
布尔值_TRUE='TRUE'
布尔值_FALSE='FALSE'
动作\签名='SIGNIN'
操作\搜索='SEARCH'
操作\u获取\u下一步\u结果='getNextResults'
状态_successed='successed'
默认等待=5
host=“192.168.158.27”
user=“admin”
password=“admin”
协议=“https”
端口=8443
query=“vm[=name rx（？i）*]&[@cpuUsage rx b.+][@cpuUsage rx b.+]”
开始时间=“10/05/2013 16:16:00”
结束时间=“10/05/2013 17:16:00”
基本url=“%s://%s:%d”%（协议、主机、端口）
login\u url=“%s/用户”%base\u url
http=HTTPRequest（）
属性={PARAM_PASSWORD:PASSWORD，
参数用户：用户，
参数动作：动作签名，
参数：1000，
PARAM_XO:BOOLEAN_TRUE}
params=http.\u encode\u url（**属性）
如果不是http.\U请求（登录url，参数）：
打印“登录失败…”
其他：
打印“登录成功..\n”
rid=1000
搜索url=“%s/search”%base\u url
状态=状态\成功
hasMoreData=布尔值\真值
已完成=布尔值\错误
总数=0
已处理=1
responseContent=“”
xml_dict={}
_response=“”
属性={PARAM_START_TIME:START_TIME，
参数结束时间：结束时间，
参数操作：操作搜索，
帕拉姆·里德：里德，
参数路径：查询}
打印“URL参数：”
打印“\t基础url=%s”%base\u url
对于属性中的参数：
打印“\t%s=%s”%（参数，属性[param]）
#查询执行开始时间
start=datetime.datetime.now（）
尽管如此：
params=http.\u encode\u url（**属性）
如果hasMoreData==布尔值_真：
#延迟10毫秒
时间。睡眠（10/1000）
#发送HTTP请求
响应=http.\U请求（搜索url，参数）
pattern=re.match（“.*？hasMoreData=\”（.*？\”*？”，响应）
如果模式：
hasMoreData=pattern.group（1）
模式=重新匹配（“*？状态=\”（*？\”*？”，响应）
如果模式：
状态=模式组（1）
pattern=re.match（“.*？完成=\”（.*？\”*？”，响应）
如果模式：
完成=模式。组（1）
pattern=re.match（“.*？处理=\”（.*？\”*？”，响应）
如果模式：
已处理=模式组（1）
pattern=re.match（“.*？总计=\”（.*？\”*？”，响应）
如果模式：
总计=模式组（1）
pattern=re.match（“.*？matched=\”（.*？\”*？”，响应）
如果模式：
匹配=模式。组（1）
attributes={PARAM_ACTION:ACTION_GET_NEXT_RESULTS，
PARAM_RID:RID}
如果匹配！="0":
response=re.sub（r'\n'，''，response）
matchObj=re.search（r’（代替您的本地网络IP，尝试使用
127.0.0.1
代替。
试试
127.0.0.1
因为您的本地主机是您请求的IP在同一台计算机上？