Python string.atof函数代码示例

def HexamerFeatures(seq,hash_matrix):
    if len(seq) < 6:
		return(0,0)
    frame_sequence = list(seq)
    frame_seq_length = len(frame_sequence)
    CDS_array = []
    for o in range(0,3):
        frame_TempStr = ''
        frame_TempStr = InitCodonSeq(o,frame_seq_length-2,3,frame_sequence)
        frame_array = frame_TempStr.split(' ') ## codon array
        frame_array.pop()
        other_num = 0
        frame_array_Len = len(frame_array) - 1
        for j in range(frame_array_Len):
            temp2 = frame_array[j]+frame_array[j+1]
            temple4 = re.compile('[atcg]{6}')
            if temple4.match(temp2):
                other_num = string.atof(other_num) + string.atof(hash_matrix[temp2])
        frame_array_Len = frame_array_Len + 2
        other_num = other_num / frame_array_Len
        CDS_array.append(other_num)      
    Mscore = max(CDS_array)
    score_distance = 0
    for m in range(0,3): #problem location
        score_distance += Mscore - CDS_array[m]
    score_distance = score_distance/float(2)   

    return(Mscore,score_distance)

def dealline(rdlin,sepin):
    rdlsplit=rdlin.split(sepin)
    x0=string.atof(rdlsplit[1])
    y0=string.atof(rdlsplit[2])
    x1=string.atof(rdlsplit[3])
    y1=string.atof(rdlsplit[4])
    return x0,y0,x1,y1

    def _read_data(self, fp, pos):
        fp.seek(pos)
        size = fp.readline().split()
        self.nrow = atoi(size[0])
        self.ncol = atoi(size[1])
        self.shape = (self.nrow, self.ncol)
        self.nnz = atoi(size[2])
        self.irow = np.empty(self.nnz, dtype=np.int)
        self.jcol = np.empty(self.nnz, dtype=np.int)

        if self.dtype is not None:
            self.values = np.empty(self.nnz, dtype=self.dtype)

        # Read in data
        k = 0
        for line in fp.readlines():
            line = line.split()
            self.irow[k] = atoi(line[0]) - 1
            self.jcol[k] = atoi(line[1]) - 1
            if self.dtype == np.int:
                self.values[k] = atoi(line[2])
            elif self.dtype == np.float:
                self.values[k] = atof(line[2])
            elif self.dtype == np.complex:
                self.values[k] = complex(atof(line[2]), atof(line[3]))
            k += 1

        return k

def monitor(url, price_accpet):
    idx = 0
    timenow = time.strftime("%Y-%m-%d %X", time.localtime())
    while True:
    #for idx in range(COUNTER):
        try:
            page = urllib2.urlopen(url, timeout=1000)
            page = unicode(page.read(), "gb2312", "ignore").encode("gb2312", "ignore")
            soup = BeautifulSoup(page, fromEncoding="gb18030")
            global subject_header
            subject_header = soup.html.head.title.string
            print subject_header
            subject_header = ''.join(subject_header.encode('utf-8').split('【')[:-1])
            print subject_header
            skuid = url.split('/')[-1].split('.')[0]
            f = urllib2.urlopen('http://p.3.cn/prices/get?skuid=J_'+skuid, timeout=5)
        except Exception, ex:
            print ex, 'timenow:%s,couldnot open this %s' % (timenow, url)
            continue
        price = json.loads(f.read())
        f.close()
        #print price_promotion
        price_promotion = price[0]['p']
        print price_promotion, price_accpet
        if string.atof(price_promotion) < string.atof(price_accpet):
            message = ''.join(['价格降低到 ', (price_promotion.encode('utf-8'))])
            subject_header = ''.join([subject_header, message])
            print subject_header, '----', message
            send_mail(message)
            break
        time.sleep(60)

def signOR(ntot,ns,curs):
        ORv={}
        snpor = curs.fetchall()
        desc = curs.description
        ntot += 1
        founds=0;
        for OR in snpor: ### check all CI
                for (name, value) in zip(desc, OR) :
                        ORv[name[0]] = value   
                pval = ORv['Pvalue'] 
                ci = ORv['CI']
               # print pval
                #print ci
                if founds == 0:
                        if  ci is not None:
                               # print 'y',ci
                                c0=string.atof(ci.split("-", 1)[0])
                                c1=string.atof(ci.split("-", 1)[1])
                                if(c1 >1 and  c0> 1)  or (c0 <1 and c1 < 1): 
                                        founds +=1
                        elif pval is not None and  pval <=0.05:
                               #print 'z', pval
                                founds +=1
                       # elif  pval is None and ci is not None:
                      
                else:
                        break  
        ns += founds
        return (ntot,ns)

  def rescale_canvas_cb(self, value):

    value = string.atof(value)
    cur_value = math.log10(self.current_zoom_factor)
    if abs(cur_value - value) > .5 * string.atof(self.zscale['resolution']):
      factor = math.pow(10.0, value) / self.current_zoom_factor
      self.zoom_by_factor(factor, 0)

 def gui_updateMarkers(self):
     M=self.GM.Marker
     M.equalize()
     n=M.number
     for i in range(n):
         gm=self.guiMarkers[i]
         s=self.guiVar[i][1].get()
         if s==0:
             M.status[i]='off'
         else:
             M.status[i]='on'
         a=gm[3].getcurselection()
         M.size[i]=string.atoi(gm[5].get(0.0,Tkinter.END))
         M.symbol[i]=gm[3].getcurselection()
         M.color[i]=gm[4].get()
         M.id[i]=gm[6].get(0.0,Tkinter.END)[:-1]
         M.id_size[i]=string.atoi(gm[7].get(0.0,Tkinter.END))
         x=string.atof(gm[8].get(0.0,Tkinter.END))
         y=string.atof(gm[9].get(0.0,Tkinter.END))
         M.xoffset[i]=x
         M.yoffset[i]=y
         M.id_color[i]=gm[10].get()
         M.id_font[i]=string.atoi(gm[11].getcurselection())
         M.line[i]=string.lower(gm[12].getcurselection())
         if M.line[i]=='none' : M.line[i]=None
         M.line_type[i]=gm[13].getcurselection()
         M.line_size[i]=string.atof(gm[14].get(0.0,Tkinter.END))
         M.line_color[i]=gm[15].get()

    def parseGSA(self, words):
        if len(words[1]):
            (self.mode, self.LATLON) = self.update(self.mode, string.atoi(words[1]), self.LATLON)
            self.fix = ["none", "2d", "3d"][string.atoi(words[1]) - 1]
        else:
            self.fix = "none"

        usedSatellites = [int(i) for i in words[2:13] if i != ""]

        for prn, sat in self.sats.iteritems():
            if prn in usedSatellites:
                sat.used = True
                sat.gsaLast = self.gsaLast
            elif self.gsaLast - sat.gsaLast > 2:
                sat.used = False

        self.gsaLast += 1

        if words[14] != "":
            self.pdop = string.atof(words[14])
        if words[15] != "":
            self.hdop = string.atof(words[15])
        if words[16] != "":
            self.vdop = string.atof(words[16])
            if self.vdop == 0:
                self.vdop = None

def down(each, j, data):
	url = 'http://www.worldweather.cn/zh/json/'+str(each)+'_zh.xml'
	html = urllib2.urlopen(url).read()
	con = json.loads(html)['city']
	name = con['cityName']
	memName = con['member']['memName']
	data.write(j, 0, name)
	data.write(j, 1, memName)
	data.write(j, 2, each)
	month_list = con['climate']['climateMonth']
	list_len = len(month_list)
	for i in range(list_len):
		#print i['month'],i['minTemp'],i['maxTemp'],i['rainfall'],i['raindays']
		minTemp = month_list[i]['minTemp']
		maxTemp = month_list[i]['maxTemp']
		rainfall = month_list[i]['rainfall']
		raindays = month_list[i]['raindays']
		print month_list[i]['month'], minTemp, maxTemp, rainfall, raindays
		if not func(minTemp):
			minTemp = 0
		if not func(maxTemp):
			maxTemp = 0
		if not func(rainfall):
			rainfall = 0
		if not func(raindays):
			raindays = 0
		data.write(j, 4*i+3, string.atof(minTemp))
		data.write(j, 4*i+4, string.atof(maxTemp))
		data.write(j, 4*i+5, string.atof(rainfall))
		data.write(j, 4*i+6, string.atof(raindays))

 def fromXYZrecord(cls,aline):
     AtomStr  = string.split(aline)[0:4]
     name = AtomStr[0]
     x = string.atof(AtomStr[1])
     y = string.atof(AtomStr[2])
     z = string.atof(AtomStr[3])
     return cls(name,[x,y,z])

 def do_lat_lon(self, words):
     if len(words[0]) == 0 or len(words[1]) == 0:  # empty strings?
         return
     if words[0][-1] == "N":
         words[0] = words[0][:-1]
         words[1] = "N"
     if words[0][-1] == "S":
         words[0] = words[0][:-1]
         words[1] = "S"
     if words[2][-1] == "E":
         words[2] = words[2][:-1]
         words[3] = "E"
     if words[2][-1] == "W":
         words[2] = words[2][:-1]
         words[3] = "W"
     if len(words[0]):
         lat = string.atof(words[0])
         frac, intpart = math.modf(lat / 100.0)
         lat = intpart + frac * 100.0 / 60.0
         if words[1] == "S":
             lat = -lat
         (self.lat, self.LATLON) = self.update(self.lat, lat, self.LATLON)
     if len(words[2]):
         lon = string.atof(words[2])
         frac, intpart = math.modf(lon / 100.0)
         lon = intpart + frac * 100.0 / 60.0
         if words[3] == "W":
             lon = -lon
         (self.lon, self.LATLON) = self.update(self.lon, lon, self.LATLON)

  def TF_rotate( self, c = [] ):
    s = c[0]
    n = string.atoi( c[1] )

    # direction
    u = numpy.array( [ 0.0, 0.0, 0.0 ] )
    u[0] = string.atof( c[2] )
    u[1] = string.atof( c[3] )
    u[2] = string.atof( c[4] )
    # angle
    t = string.atof( c[5] )

    self.cart()
    atom = self.get( n )
    if atom.symbol != s:
      raise Warning( "Symbol mismatch" )
    # end if
    origo = atom.position
    print " TF/rotate origo"
    atom.info()
    print " TF/rotate",u,t

    R = ROT(u,t)

    # copy atoms
    for atom in self.atoms:
      dv = atom.position - origo
      dv = numpy.dot(R,dv)
      atom.position = dv + origo
    # end for
    self.direct()

    return self

def AUTOatof(input_string):
    #Sometimes AUTO messes up the output.  I.e. it gives an
    #invalid floating point number of the form x.xxxxxxxE
    #instead of x.xxxxxxxE+xx.  Here we assume the exponent
    #is 0 and make it into a real real number :-)
    try:
        value=string.atof(input_string)
    except (ValueError):
        try:
            if input_string[-1] == "E":
                #  This is the case where you have 0.0000000E
                value=string.atof(strip(input_string)[0:-1])
            elif input_string[-4] == "-":
                #  This is the case where you have x.xxxxxxxxx-yyy
                value=0.0
            else:
                print "Encountered value I don't understand"
                print input_string
                print "Setting to 0"
                value=0.0
        except:
            print "Encountered value which raises an exception while processing!!!"
            print input_string
            print "Setting to 0"
            value=0.0
            
            
    return value

    def storeTimedCurrentCostDatav2(self, reftimestamp, ccdb, hist):
        global trc
        trc.FunctionEntry("storeTimedCurrentCostDatav2")

        # months
        for i in range(1, 10):
            key = "m0" + str(i)
            ccdb.StoreMonthData(self.GetOldMonth(reftimestamp, i), atoi(hist['mths'][key]))
        for i in range(10, 13):
            key = "m" + str(i)
            ccdb.StoreMonthData(self.GetOldMonth(reftimestamp, i), atoi(hist['mths'][key]))

        # days
        for i in range(1, 10):
            key = "d0" + str(i)
            ccdb.StoreDayData(self.GetOldDay(reftimestamp, i),  atoi(hist['days'][key]))
        for i in range(10, 32):
            key = "d" + str(i)
            ccdb.StoreDayData(self.GetOldDay(reftimestamp, i),  atoi(hist['days'][key]))

        # hours
        for i in range(2, 9, 2):
            key = "h0" + str(i)
            ccdb.StoreHourData(self.GetOldHour(reftimestamp, i - 2),  atof(hist['hrs'][key]))
        for i in range(10, 27, 2):
            key = "h" + str(i)
            ccdb.StoreHourData(self.GetOldHour(reftimestamp, i - 2),  atof(hist['hrs'][key]))

        trc.FunctionExit("storeTimedCurrentCostDatav2")

 def usageAct(self):
     name=self.__name
     pid=self.__pid
     useAge="top -bn 1 -p %s |grep %s | awk '{print $9}'"%(pid,pid)
     vcpustime="virsh vcpuinfo %s |grep 'CPU time'|awk '{split($3,b,\"s\");print b[1]}'"%(name)
     usedtime="virsh cpu-stats %s --total|awk 'NR>2{print $2}'|awk 'BEGIN{sum=0}{sum+=$1}END{print sum}'"%(name)
     
     files=os.popen(useAge)
     useAgeTmp=files.readline()
     
     if useAgeTmp:
         useAge=string.atof(useAgeTmp)
     else:
         useAge=0
         
     files=os.popen(usedtime)
     usedTimeTmp=files.readline()
     if usedTimeTmp:
         usedTime=string.atof(usedTimeTmp)
     else:
         usedTime=0
     files=os.popen(vcpustime)
     sts=""
     while True:
         strs=files.readline()
         if strs:
             sts+=strs[:-1]+","
         else:
             break
     self.__dataSlot["cpu"]["core_time"]=sts
     self.__dataSlot["cpu"]["usedTime"]="%.3f"%(usedTime)
     self.__dataSlot["cpu"]["useAge"]=useAge