Python __builtin__ 模块，range() 实例源码

def handleargs(arglist):
    """Take list of arguments and extract/create proper start, stop, and step
    values and return in a tuple"""
    try:
        if len(arglist) == 1:
            return 0, int(arglist[0]), 1
        elif len(arglist) == 2:
            return int(arglist[0]), int(arglist[1]), 1
        elif len(arglist) == 3:
            if arglist[2] == 0:
                raise ValueError("step argument must not be zero")
            return tuple(int(x) for x in arglist)
        else:
            raise TypeError("range() accepts 1-3 arguments, given", len(arglist))
    except TypeError:
        raise TypeError("range() arguments must be numbers or strings "
        "representing numbers")

def elements(self):
        '''Iterator over elements repeating each as many times as its count.

        >>> c = Counter('ABCABC')
        >>> sorted(c.elements())
        ['A', 'A', 'B', 'B', 'C', 'C']

        If an element's count has been set to zero or is a negative number,
        elements() will ignore it.

        '''
        for elem, count in iteritems(self):
            for _ in range(count):
                yield elem

    # Override dict methods where the meaning changes for Counter objects.

def intervals(_min, _max=None, size=1):
    """
    RETURN (min, max) PAIRS OF GIVEN SIZE, WHICH COVER THE _min, _max RANGE
    THE LAST PAIR MAY BE SMALLER
    Yes!  It's just like range(), only cooler!
    """
    if _max == None:
        _max = _min
        _min = 0
    _max = int(Math.ceiling(_max))
    _min = int(Math.floor(_min))

    output = ((x, min(x + size, _max)) for x in __builtin__.range(_min, _max, size))
    return output

def __init__(self, N):
        self.edges = []
        self.alignments = []
        self.affines = [ Affine() for i in range(N) ]

def get_reference_radecs(self):
        return [self.affines[fieldi].getReferenceRadec()
                for fieldi in range(len(self.affines))]

def get_all_dradec(self, apply=False):
        alldra = []
        allddec = []
        for ei in range(len(self.edges)):
            (ra,dec,dra,ddec) = self.get_edge_dradec_arcsec(ei, corrected=apply)
            alldra.append(dra)
            allddec.append(ddec)
        return np.hstack(alldra), np.hstack(allddec)

def add_edge(self, *args):
        S = args[12]
        good = np.zeros_like(S)
        fore = args[15]
        good[S] = (fore > 0.5)
        G = [args[i][good] for i in range(2,6)]
        bad = np.logical_not(good)
        B = [args[i][bad] for i in range(2,6)]
        self.edges.append(args + tuple(G) + tuple(B) + (good, bad))

def plotallmatches(self):
        for ei in range(len(self.edges)):
            self.plotmatchedstars(ei)

    # one plot per edge

def get_mags(self, TT, apply, magcol='mag1', magerrcol='mag1_err'):
        alldd = []
        allmagI = []
        allmagJ = []
        allmagerrI = []
        allmagerrJ = []
        for ei in range(len(self.edges)):
            good = self.edge_good(ei)
            ii,jj = self.edge_ij(ei)
            I,J = self.edge_IJ(ei)
            (r,d, dra,ddec) = self.get_edge_dradec_arcsec(ei, corrected=apply,
                                                          goodonly=True)
            dd = np.sqrt(dra**2 + ddec**2)
            alldd.append(dd)
            # 'I' is an int array
            # 'good' is a bool array of size == size(I)
            # number of True elements in 'good' == len(dra)
            magI = TT[ii][I][good].get(magcol)
            magJ = TT[jj][J][good].get(magcol)
            allmagI.append(magI)
            allmagJ.append(magJ)
            if magerrcol in TT[ii].columns():
                allmagerrI.append(TT[ii].get(magerrcol)[I][good])
                allmagerrJ.append(TT[jj].get(magerrcol)[J][good])

        alldd = np.hstack(alldd)
        allmagI = np.hstack(allmagI)
        allmagJ = np.hstack(allmagJ)
        allmagerrI = np.hstack(allmagerrI)
        allmagerrJ = np.hstack(allmagerrJ)
        return (allmagI, allmagJ, alldd, magcol, allmagerrI, allmagerrJ)

def magmagplot(self, TT, magcol, filtname, weighted=True):
        plt.clf()
        m1 = []
        m2 = []
        ww = []
        for ei in range(self.nedges()):
            i,j = self.edge_ij(ei)
            I,J = self.edge_IJ(ei)
            Ti = TT[i][I]
            Tj = TT[j][J]
            mag1 = Ti.get(magcol)
            mag2 = Tj.get(magcol)
            weights = self.get_edge_all_weights(ei)
            K = (mag1 < 50) * (mag2 < 50)
            m1.append(mag1[K])
            m2.append(mag2[K])
            ww.append(weights[K])
        m1 = np.hstack(m1)
        m2 = np.hstack(m2)
        ww = np.hstack(ww)
        if weighted:
            loghist(m1, m2, weights=ww)
        else:
            loghist(m1, m2)
        plt.xlabel('%s (mag)' % filtname)
        plt.ylabel('%s (mag)' % filtname)
        return ww

def n_sip_terms(sip_order):
    assert(sip_order >= 2)
    n = 0
    for order in range(2, sip_order+1):
        n += 2 * (order + 1)
    return n

# for parallelization of matching in 'intrabrickshift'...

def oldrange(*args, **kwargs):
        return list(builtins.range(*args, **kwargs))

def lrange(*args, **kwargs):
        return list(range(*args, **kwargs))

def __init__(self, whatrange):    ## range example --> "23-56"
    try:
        ran = whatrange.split("-")
        self.minimum = int(ran[0])
        self.maximum = int(ran[1])
        self.__count = self.maximum - self.minimum + 1
        self.width = len(ran[0])
        self.current = self.minimum
    except:
        raise FuzzException(FuzzException.FATAL, "Bad range format (eg. \"23-56\")")

def __init__(self, prange):    ## range example --> "0-ffa"
    try:
        ran = prange.split("-")
        self.minimum = int(ran[0],16)
        self.maximum = int(ran[1],16)
        self.__count = self.maximum - self.minimum + 1
        self.current = self.minimum
    except:
        raise Exception, "Bad range format (eg. \"0-ffa\")"

def __init__(self, prange):    ## range example --> "0-ffa"
    try:
        ran = prange.split("-")
        self.minimum=int(ran[0],16)
        self.maximum=int(ran[1],16)
        self.__count=-1
    except:
        raise Exception, "Bad range format (eg. \"0-ffa\")"

def __init__(self, l):   
    if l.find("\\") >= 0:
        l = l.replace("\\-", "$SEP$")
        l = l.replace("\\\\", "$SCAP$")

        self.l = l.split("-")

        for i in __builtin__.range(len(self.l)):
        self.l[i] = self.l[i].replace("$SEP$", "-")
        self.l[i] = self.l[i].replace("$SCAP$", "\\")
    else:
        self.l = l.split("-")

    self.__count = len(self.l)
    self.current = 0

def __iterate__():
    '''Iterate through all enumeration ids defined in the database.'''
    for n in __builtin__.range(idaapi.get_enum_qty()):
        yield idaapi.getn_enum(n)
    return

def range():
    '''Return the total address range of the database.'''
    return config.bounds()

def __new__(cls):
        '''Returns a list of all of the functions in the current database (ripped from idautils).'''
        left,right = range()

        # find first function chunk
        ch = idaapi.get_fchunk(left) or idaapi.get_next_fchunk(left)
        while ch and ch.startEA < right and (ch.flags & idaapi.FUNC_TAIL) != 0:
            ch = idaapi.get_next_fchunk(ch.startEA)

        # iterate through the rest of the functions in the database
        result = []
        while ch and ch.startEA < right:
            result.append(ch.startEA)
            ch = idaapi.get_next_func(ch.startEA)
        return result

def __iterate__(cls):
        '''Iterates through all of the functions in the current database (ripped from idautils).'''
        left,right = range()

        # find first function chunk
        ch = idaapi.get_fchunk(left) or idaapi.get_next_fchunk(left)
        while ch and ch.startEA < right and (ch.flags & idaapi.FUNC_TAIL) != 0:
            ch = idaapi.get_next_fchunk(ch.startEA)

        # iterate through the rest of the functions in the database
        while ch and ch.startEA < right:
            yield ch.startEA
            ch = idaapi.get_next_func(ch.startEA)
        return

def __iterate__(cls, **type):
        if not type: type = {'predicate':lambda n: True}
        res = __builtin__.range(idaapi.get_nlist_size())
        for k,v in type.iteritems():
            res = __builtin__.list(cls.__matcher__.match(k, v, res))
        for n in res: yield n

def __iterate__(cls, **type):
        if not type: type = {'predicate':lambda n: True}
        res = __builtin__.range(idaapi.get_entry_qty())
        for k,v in type.iteritems():
            res = __builtin__.list(cls.__matcher__.match(k, v, res))
        for n in res: yield n

def __index__(cls, ea):
        '''Returns the index of the entry-point at the specified ``address``.'''
        f = utils.compose(idaapi.get_entry_ordinal, idaapi.get_entry)
        iterable = itertools.imap(utils.compose(utils.fap(f, lambda n:n), __builtin__.tuple), __builtin__.range(idaapi.get_entry_qty()))
        filterable = itertools.ifilter(utils.compose(utils.first, functools.partial(operator.eq, ea)), iterable)
        result = itertools.imap(utils.second, filterable)
        return __builtin__.next(result, None)

def array(cls, ea):
        '''Return the values of the array at address ``ea``.'''
        ea = interface.address.within(ea)
        numerics = {
            idaapi.FF_BYTE : 'B',
            idaapi.FF_WORD : 'H',
            idaapi.FF_DWRD : 'L',
            idaapi.FF_QWRD : 'Q',
            idaapi.FF_FLOAT : 'f',
            idaapi.FF_DOUBLE : 'd',
        }
        strings = {
            1 : 'c',
            2 : 'u',
        }
        fl = type.flags(ea)
        elesize = idaapi.get_full_data_elsize(ea, fl)
        if fl & idaapi.FF_ASCI == idaapi.FF_ASCI:
            t = strings[elesize]
        elif fl & idaapi.FF_STRU == idaapi.FF_STRU:
            t, size = type.structure.id(ea), idaapi.get_item_size(ea)
            return [ cls.struc(ea, id=t) for ea in __builtin__.range(ea, ea+size, structure.size(t)) ]
        else:
            ch = numerics[fl & idaapi.DT_TYPE]
            t = ch.lower() if fl & idaapi.FF_SIGN == idaapi.FF_SIGN else ch
        res = array.array(t, read(ea, type.array.size(ea)))
        if len(res) != type.array.length(ea):
            logging.warn("{:s}.get({:x}) : Unexpected length : ({:d} != {:d})".format('.'.join((__name__, cls.__name__)), ea, len(res), type.array.length(ea)))
        return res

def genrange(*a):
    """Function to implement 'range' as a generator"""
    start, stop, step = handleargs(a)
    value = start
    while value < stop:
        yield value
        value += step

def __init__(self, *a):
        """ Initialize start, stop, and step values along with calculating the
        nubmer of values (what __len__ will return) in the range"""
        self.start, self.stop, self.step = handleargs(a)
        self.len = max(0, (self.stop - self.start) // self.step)

def __repr__(self):
        """implement repr(x) which is also used by print"""
        return 'range(%r, %r, %r)' % (self.start, self.stop, self.step)

def __getitem__(self, i):
        """implement x[i]"""
        if 0 <= i <= self.len:
            return self.start + self.step * i
        else:
            raise IndexError, 'range[i] index out of range'

def lrange(*args, **kwargs):
        return list(range(*args, **kwargs))

def oldrange(*args, **kwargs):
        return list(builtins.range(*args, **kwargs))

def lrange(*args, **kwargs):
        return list(range(*args, **kwargs))

def _func_setvar(self, *namesvalues):
        if len(namesvalues) % 2:
            msg = 'setvar function needs an even number of arguments'
            raise FyppFatalError(msg)
        for ind in range(0, len(namesvalues), 2):
            self.define(namesvalues[ind], namesvalues[ind + 1])

def _process_arguments(self, args, keywords):
        argdict = {}
        nargs = min(len(args), len(self._argnames))
        for iarg in range(nargs):
            argdict[self._argnames[iarg]] = args[iarg]
        if nargs < len(args):
            if self._varargs is None:
                msg = "macro '{0}' called with too many positional arguments "\
                      "(expected: {1}, received: {2})"\
                      .format(self._name, len(self._argnames), len(args))
                raise FyppFatalError(msg, self._fname, self._spans[0])
            else:
                argdict[self._varargs] = tuple(args[nargs:])
        elif self._varargs is not None:
            argdict[self._varargs] = ()
        for argname in self._argnames[:nargs]:
            if argname in keywords:
                msg = "got multiple values for argument '{0}'".format(argname)
                raise FyppFatalError(msg, self._fname, self._spans[0])
        if self._varargs is not None and self._varargs in keywords:
            msg = "got unexpected keyword argument '{0}'".format(self._varargs)
            raise FyppFatalError(msg, self._fname, self._spans[0])
        argdict.update(keywords)
        if nargs < len(self._argnames):
            for argname in self._argnames[nargs:]:
                if argname in argdict:
                    pass
                elif argname in self._defaults:
                    argdict[argname] = self._defaults[argname]
                else:
                    msg = "macro '{0}' called without mandatory positional "\
                          "argument '{1}'".format(self._name, argname)
                    raise FyppFatalError(msg, self._fname, self._spans[0])
        return argdict

def oldrange(*args, **kwargs):
        return list(builtins.range(*args, **kwargs))

def lrange(*args, **kwargs):
        return list(range(*args, **kwargs))

def lrange(*args, **kwargs):
        return list(range(*args, **kwargs))

def oldrange(*args, **kwargs):
        return list(builtins.range(*args, **kwargs))

def lrange(*args, **kwargs):
        return list(range(*args, **kwargs))

def __init__(self, whatrange):    ## range example --> "23-56"
    try:
        ran = whatrange.split("-")
        self.minimum = int(ran[0])
        self.maximum = int(ran[1])
        self.__count = self.maximum - self.minimum + 1
        self.width = len(ran[0])
        self.current = self.minimum
    except:
        raise FuzzException(FuzzException.FATAL, "Bad range format (eg. \"23-56\")")

def __init__(self, prange):    ## range example --> "0-ffa"
    try:
        ran = prange.split("-")
        self.minimum = int(ran[0],16)
        self.maximum = int(ran[1],16)
        self.__count = self.maximum - self.minimum + 1
        self.current = self.minimum
    except:
        raise Exception, "Bad range format (eg. \"0-ffa\")"

def __init__(self, prange):    ## range example --> "0-ffa"
    try:
        ran = prange.split("-")
        self.minimum=int(ran[0],16)
        self.maximum=int(ran[1],16)
        self.__count=-1
    except:
        raise Exception, "Bad range format (eg. \"0-ffa\")"

def __init__(self, l):   
    if l.find("\\") >= 0:
        l = l.replace("\\-", "$SEP$")
        l = l.replace("\\\\", "$SCAP$")

        self.l = l.split("-")

        for i in __builtin__.range(len(self.l)):
        self.l[i] = self.l[i].replace("$SEP$", "-")
        self.l[i] = self.l[i].replace("$SCAP$", "\\")
    else:
        self.l = l.split("-")

    self.__count = len(self.l)
    self.current = 0

def oldrange(*args, **kwargs):
        return list(builtins.range(*args, **kwargs))

def lrange(*args, **kwargs):
        return list(range(*args, **kwargs))

def oldrange(*args, **kwargs):
        return list(builtins.range(*args, **kwargs))

def lrange(*args, **kwargs):
        return list(range(*args, **kwargs))

def oldrange(*args, **kwargs):
        return list(builtins.range(*args, **kwargs))

def lrange(*args, **kwargs):
        return list(range(*args, **kwargs))

def lrange(*args, **kwargs):
        return list(range(*args, **kwargs))