Python reversed函数代码示例

def reference_number(data):
    chk = -sum(int(x) * [7, 3, 1][i % 3]
               for i, x in enumerate(data[::-1])) % 10
    ref = '%s%d' % (data, chk)
    return ' '.join(
        reversed(
            [''.join(reversed(x)) for x in grouper(5, reversed(ref), '')]))

 def validate_anyOf(self, *args, **kwargs):
     for error in super(SchemaValidator, self).validate_anyOf(*args, **kwargs):
         # Split the suberrors up by which subschema they are from
         subschema_errors = defaultdict(list)
         for sube in error.context:
             subschema_errors[sube.schema_path[0]].append(sube)
         # Find the subschemas that did not have a 'type' error validating the instance at this path
         no_type_errors = dict(subschema_errors)
         valid_types = set()
         for i, errors in subschema_errors.iteritems():
             for e in errors:
                 if e.validator == 'type' and not e.path:
                     # Remove from the no_type_errors dict
                     no_type_errors.pop(i, None)
                     # Add the valid types to the list of all valid types
                     if self.is_type(e.validator_value, 'string'):
                         valid_types.add(e.validator_value)
                     else:
                         valid_types.update(e.validator_value)
         if not no_type_errors:
             # If all of the branches had a 'type' error, create our own virtual type error with all possible types
             for e in self.descend(error.instance, {'type': valid_types}):
                 yield e
         elif len(no_type_errors) == 1:
             # If one of the possible schemas did not have a 'type' error, assume that is the intended one and issue
             # all errors from that subschema
             for e in no_type_errors.values()[0]:
                 e.schema_path.extendleft(reversed(error.schema_path))
                 e.path.extendleft(reversed(error.path))
                 yield e
         else:
             yield error

    def wrap(f):
        @wraps(f)
        def inner_f(*args):
            val = f(*args)
            if nullable and val == ffi.NULL:
                return None
            elif returns_string:
                return ffi.string(val)
            return val

        # this insanity inserts a formatted argspec string
        # into the function's docstring, so that sphinx
        # gets the right args instead of just the wrapper args
        args, varargs, varkw, defaults = inspect.getargspec(f)
        defaults = () if defaults is None else defaults
        defaults = ["\"{}\"".format(a) if type(a) == str else a for a in defaults]
        l = ["{}={}".format(arg, defaults[(idx+1)*-1])
             if len(defaults)-1 >= idx else
             arg for idx, arg in enumerate(reversed(list(args)))]
        if varargs:
            l.append('*' + varargs)
        if varkw:
            l.append('**' + varkw)
        doc = "{}({})\n\nC: ``{}``\n\n{}".format(f.__name__, ', '.join(reversed(l)), decl, f.__doc__)
        inner_f.__doc__ = doc
        return inner_f

 def instructions_reversed(self):
     """Iterate in reverse order over all instructions in the module."""
     for function in reversed(self.functions[:]):
         for inst in function.instructions_reversed():
             yield inst
     for inst in reversed(self.global_insts[:]):
         yield inst

    def test_walk_versions_all_true(self, _migrate_up, _migrate_down):
        self.REPOSITORY.latest = 20
        self.migration_api.db_version.return_value = self.INIT_VERSION

        self._walk_versions(self.engine, snake_walk=True, downgrade=True)

        versions = range(self.INIT_VERSION + 1, self.REPOSITORY.latest + 1)
        upgraded = []
        for v in versions:
            upgraded.append(mock.call(self.engine, v, with_data=True))
            upgraded.append(mock.call(self.engine, v))
        upgraded.extend(
            [mock.call(self.engine, v) for v in reversed(versions)]
        )
        self.assertEqual(upgraded, self._migrate_up.call_args_list)

        downgraded_1 = [
            mock.call(self.engine, v - 1, with_data=True) for v in versions
        ]
        downgraded_2 = []
        for v in reversed(versions):
            downgraded_2.append(mock.call(self.engine, v - 1))
            downgraded_2.append(mock.call(self.engine, v - 1))
        downgraded = downgraded_1 + downgraded_2
        self.assertEqual(self._migrate_down.call_args_list, downgraded)

    def run(self):

        self.correct_octave_errors_by_chunks()
        self.remove_extreme_values()

        self.correct_jumps()
        self.pitch = list(reversed(self.pitch))
        self.correct_jumps()
        self.pitch = list(reversed(self.pitch))

        self.filter_noise_region()

        self.correct_oct_error()
        self.pitch = list(reversed(self.pitch))
        self.correct_oct_error()
        self.pitch = list(reversed(self.pitch))

        self.correct_octave_errors_by_chunks()
        self.filter_chunks_by_energy(chunk_limit=60)

        if self.out:
            self.data['pitch'] = self.pitch
            with open(self.fname[:-5] + "_filtered.json", 'w') as f: json.dump(self.data, f)

        return self.pitch

def _balance_tags(tags):
  """Throw out any close tags without an open tag.

  If {@code <table>} is used for formatting, embedded HTML shouldn't be able
  to use a mismatched {@code </table>} to break page layout.

  Args:
    tags: The list of all tags in this text.

  Returns:
    A string containing zero or more closed tags that close all elements that
    are opened in tags but not closed.
  """
  open_tags = []
  for i, tag in enumerate(tags):
    if tag[1] == '/':
      index = len(open_tags) - 1
      while index >= 0 and open_tags[index] != tag:
        index -= 1

      if index < 0:
        tags[i] = ''  # Drop close tag.
      else:
        tags[i] = ''.join(reversed(open_tags[index:]))
        del open_tags[index:]

    elif not _HTML5_VOID_ELEMENTS_RE.match(tag):
      open_tags.append('</' + tag[1:])

  return ''.join(reversed(open_tags))

 def filterRevisions(self, revisions, filter=None, max_revs=None):
     """Filter a set of revisions based on any number of filter criteria.
     If specified, filter should be a dict with keys corresponding to
     revision attributes, and values of 1+ strings"""
     if not filter:
         if max_revs is None:
             for rev in reversed(revisions):
                 yield DevRevision(rev)
         else:
             for index,rev in enumerate(reversed(revisions)):
                 if index >= max_revs:
                     break
                 yield DevRevision(rev)
     else:
         for index, rev in enumerate(reversed(revisions)):
             if max_revs and index >= max_revs:
                 break
             try:
                 for field,acceptable in filter.iteritems():
                     if not hasattr(rev, field):
                         raise DoesNotPassFilter
                     if type(acceptable) in (str, unicode):
                         if getattr(rev, field) != acceptable:
                             raise DoesNotPassFilter
                     elif type(acceptable) in (list, tuple, set):
                         if getattr(rev, field) not in acceptable:
                             raise DoesNotPassFilter
                 yield DevRevision(rev)
             except DoesNotPassFilter:
                 pass

    def execute(self, slot, subindex, roi, result):
        if numpy.prod(roi.stop - roi.start) > 1e9:
            logger.error("Requesting a very large volume from DVID: {}\n"\
                         "Is that really what you meant to do?"
                         .format( roi ))
            
        # TODO: Modify accessor implementation to accept a pre-allocated array.

# FIXME: Disabled throttling for now.  Need a better heuristic or explicit setting.
#         # For "heavy" requests, we'll use the throttled accessor
#         HEAVY_REQ_SIZE = 256*256*10
#         if numpy.prod(result.shape) > HEAVY_REQ_SIZE:
#             accessor = self._throttled_accessor
#         else:
#             accessor = self._default_accessor

        accessor = self._default_accessor # FIXME (see above)
        
        if self._transpose_axes:
            roi_start = tuple(reversed(roi.start))
            roi_stop = tuple(reversed(roi.stop))
            result[:] = accessor.get_ndarray(roi_start, roi_stop).transpose()
        else:
            result[:] = accessor.get_ndarray(roi.start, roi.stop)
        return result

def _get_flatmirror_attrdict(cls, add, exclude, bases, dict_factory):
    attrdict = dict_factory()
    slotset = set()
    rev_mro = reversed(cls.mro())
    supercls = next(rev_mro)
    for basecls in reversed(bases):
        # skip some redundant base classes (typically: object)
        if issubclass(basecls, supercls):
            supercls = next(rev_mro)
        else:
            break
    while True:
        slots = getattr(supercls, '__slots__', ())
        excl = frozenset(slots).union(exclude)
        slotset.update(slots)
        for attrname, obj in supercls.__dict__.items():
            if attrname not in excl:
                attrdict[attrname] = obj
        if supercls is not cls:
            supercls = next(rev_mro)
        else:
            break
    if add is not None:
        attrdict.update(add)
    slots = attrdict.get('__slots__', None)
    if slots is not None:
        if isinstance(slots, basestring):
            slots = (slots,)
        slotset.update(slots)
        attrdict['__slots__'] = tuple(slotset)
    return attrdict

def list_changes(upstream, feature, paths=[]):
    feature_revs = tuple(list_revs(upstream, feature, paths=paths))
    upstream_revs = tuple(list_revs(feature, upstream, paths=paths))

    feature_cids = dict([
        (c.change_id, c) for c in feature_revs if c.change_id is not None ])
    upstream_cids = dict([
        (c.change_id, c) for c in upstream_revs if c.change_id is not None ])

    incoming = filter(
        lambda r: r.change_id and r.change_id not in feature_cids,
        reversed(upstream_revs))
    outgoing = filter(
        lambda r: r.change_id and r.change_id not in upstream_cids,
        reversed(feature_revs))
    common = filter(
        lambda r: r.change_id in upstream_cids,
        reversed(feature_revs))
    upstream_unknown = filter(
        lambda r: r.change_id is None,
        reversed(upstream_revs))
    feature_unknown = filter(
        lambda r: r.change_id is None,
        reversed(feature_revs))

    return incoming, outgoing, common, upstream_unknown, feature_unknown

 def try_to_bump(self, left, right):
     left_edge = []
     # Instead of bumping left and right, one has to bump all [..., left] and [right, ...] children.
     # It may be that the child just before the left had a branch that overlaps with the right side branches.
     for child in self.child_blocks:
         left_edge += child.right_edges
         if child is left:
             break
     right_edge = []
     for child in reversed(self.child_blocks):
         right_edge += child.left_edges
         if child is right:
             break
     adjust = prefs.edge_width
     while (not bump_polygons(left_edge, right_edge, adjust)) and adjust < 1000:
         adjust += prefs.edge_width
     amount = adjust - 3 * prefs.edge_width
     if amount > 0:
         a2 = amount / 2
         self.width -= amount
         self.left += a2
         for child in self.child_blocks:
             child.move(a2, 0)
             if child is left:
                 break
         for child in reversed(self.child_blocks):
             child.move(-a2, 0)
             if child is right:
                 break

    def new_enum_type(self, name, enumerators, enumvalues, CTypesInt):
        assert isinstance(name, str)
        reverse_mapping = dict(zip(reversed(enumvalues),
                                   reversed(enumerators)))
        #
        class CTypesEnum(CTypesInt):
            __slots__ = []
            _reftypename = '%s &' % name

            def _get_own_repr(self):
                value = self._value
                try:
                    return '%d: %s' % (value, reverse_mapping[value])
                except KeyError:
                    return str(value)

            def _to_string(self, maxlen):
                value = self._value
                try:
                    return reverse_mapping[value]
                except KeyError:
                    return str(value)
        #
        CTypesEnum._fix_class()
        return CTypesEnum

    def _FindNodeValue(self, key):
        # |found_node_list| will be all the nodes that |key| has been found in.
        # |checked_node_set| are those that have been checked.
        info = self._value_info.get(key)
        if info is None:
            info = ([], set())
            self._value_info[key] = info
        found_node_list, checked_node_set = info

        # Check all the nodes not yet checked for |key|.
        newly_found = []
        for node in reversed(self._nodes):
            if node in checked_node_set:
                break
            value = node.Get(key)
            if value is not None:
                newly_found.append(node)
            checked_node_set.add(node)

        # The nodes will have been found in reverse stack order. After extending
        # the found nodes, the freshest value will be at the tip of the stack.
        found_node_list.extend(reversed(newly_found))
        if not found_node_list:
            return None

        return found_node_list[-1]._value.get(key)

def signature_argspec(f):
    from inspect import signature, Parameter, _empty

    try:
        if NO_ARGSPEC:
            sig = signature(f, follow_wrapped=False)
        else:
            sig = signature(f)
    except ValueError:
        raise TypeError("unsupported callable")
    args = list(
        k for k, v in sig.parameters.items() if v.kind in (Parameter.POSITIONAL_ONLY, Parameter.POSITIONAL_OR_KEYWORD)
    )
    varargs = None
    keywords = None
    for k, v in sig.parameters.items():
        if v.kind == Parameter.VAR_POSITIONAL:
            varargs = k
        elif v.kind == Parameter.VAR_KEYWORD:
            keywords = k
    defaults = []
    for a in reversed(args):
        default = sig.parameters[a].default
        if default is _empty:
            break
        else:
            defaults.append(default)
    if defaults:
        defaults = tuple(reversed(defaults))
    else:
        defaults = None
    return FakeArgSpec(args, varargs, keywords, defaults)