python类filterfalse()的实例源码

def display_reviews(self, message):
        def filter_predicate(x):
            return self.__cache.IsInCache(self.__get_cachekey(x, message))

        reviews = self.__crucible_regex.findall(message.body['text'])
        reviews = filterfalse(filter_predicate, reviews)
        if reviews:
            attachments = []
            for reviewid in filterfalse(filter_predicate, reviews):
                self.__cache.AddToCache(self.__get_cachekey(reviewid, message))

                try:
                    msg = self.__get_review_message(reviewid, message._client)
                    if msg is None:
                        msg = self.__get_reviewnotfound_message(reviewid)

                    attachments.append(msg)
                except requests.exceptions.HTTPError as e:
                    if e.response.status_code == 401:
                        print('Invalid auth')

                    raise
            if attachments:
                message.send_webapi('', json.dumps(attachments))

def display_issues(self, message):
        attachments = []

        issues = self.__jira_regex.findall(message.body['text'])

        def filter_predicate(x):
            return self.__cache.IsInCache(self.__get_cachekey(x, message))

        for issue in filterfalse(filter_predicate, issues):
            self.__cache.AddToCache(self.__get_cachekey(issue, message))
            issue_message = self.get_issue_message(issue)
            if issue_message is None:
                issue_message = self.__get_issuenotfound_message(issue)

            attachments.append(issue_message)

        if attachments:
            message.send_webapi('', json.dumps(attachments))

def unique_everseen(iterable, key=None):
    "List unique elements, preserving order. Remember all elements ever seen."
    # unique_everseen('AAAABBBCCDAABBB') --> A B C D
    # unique_everseen('ABBCcAD', str.lower) --> A B C D
    seen = set()
    seen_add = seen.add
    if key is None:
        for element in itertools.filterfalse(seen.__contains__, iterable):
            seen_add(element)
            yield element
    else:
        for element in iterable:
            k = key(element)
            if k not in seen:
                seen_add(k)
                yield element

def unique_everseen(iterable, key=None):
    """List unique elements, preserving order. Remember all elements ever seen.

    The snippet is taken form https://docs.python.org/3.6/library/itertools.html#itertools-recipes
    >>> unique_everseen('AAAABBBCCDAABBB')
    A B C D
    >>> unique_everseen('ABBCcAD', str.lower)
    A B C D
    """
    seen = set()
    seen_add = seen.add
    if key is None:
        for element in filterfalse(seen.__contains__, iterable):
            seen_add(element)
            yield element
    else:
        for element in iterable:
            k = key(element)
            if k not in seen:
                seen_add(k)
                yield element

def main():
    # ????????????
    # ??accumulate()????????????,????islice()?????????len(items)-2?????None????????
    for n in itertools.islice(itertools.accumulate(cost(item) for item in items[1:]), len(items) - 2, None):
        print(n)

    # ?????????????
    print(n / (len(items) - 1))

    # ?????????
    owners = {}
    for ky, grp in itertools.groupby(sorted(items[1:], key=owner), key=owner):
        owners[ky] = len(list(grp))
    for member in members[1:]:
        print(member[1], " : ", owners[member[0]])

    # ??????returned()???,???????????????.???filterfalse()??????,???????????????,????????????
    print([items[int(loan[1])] for loan in itertools.filterfalse(returned, loans)])

def make_node_set(node_set, reverse=False):
    ids = set()

    def is_unique_id(node):
        node_id = id(node)
        if node_id in ids:
            return False
        else:
            ids.add(node_id)
            return True

    if not isinstance(node_set, list):
        node_set = [node_set]

    non_node_member = next(filterfalse(is_any_node, node_set), False)
    if non_node_member:
        format_str = 'Constructed node set that includes {0} object "{1}"'
        raise HqueryEvaluationError(format_str.format(object_type_name(non_node_member), non_node_member))

    node_set = list(sorted(filter(is_unique_id, node_set), key=lambda n: n.hq_doc_index, reverse=reverse))

    return node_set

def download_manga(manga_name, range_start=1, range_end=None, b_make_cbz=False, remove=False):
    """Download a range of a chapters"""

    chapter_urls = get_chapter_urls(manga_name)

    if range_end == None : range_end = max(chapter_urls.keys())

    for chapter, url in filterfalse (lambda chapter_url:
                                     chapter_url[0] < range_start
                                     or chapter_url[0] > range_end,
                                     chapter_urls.items()):
        chapter_number = get_chapter_number(url)

        print('===============================================')
        print('Chapter ' + chapter_number)
        print('===============================================')

        image_urls = get_chapter_image_urls(url)
        download_urls(image_urls, manga_name, chapter_number)
        download_dir = './{0}/{1}'.format(manga_name, chapter_number)
        if b_make_cbz is True:
            make_cbz(download_dir)
            if remove is True: shutil.rmtree(download_dir)

def members():
    all_users = json.loads(database.get_all_users())
    if not all_users['ok']:
        flask.abort(500)

    users = [User(username=user['username'], skills=user['skills'], points=user['points'], last_seen='Not Available')
             for user in all_users['response']]

    order = flask.request.args.get('order')
    lang = flask.request.args.get('lang', '').lower()

    if order == 'points':
        users.sort(key=attrgetter('points'), reverse=True)
    else:
        users.sort(key=attrgetter('username'))

    if lang:
        t1, t2 = tee(users)
        lang_yes = filter(lambda user: lang in user.skills.lower(), t1)
        lang_no = filterfalse(lambda user: lang in user.skills.lower(), t2)

        users = list(lang_yes) + list(lang_no)

    return flask.render_template('members.html', members=users)

def uniq(iterable, key=None):
    "List unique elements, preserving order. Remember all elements ever seen."
    # unique_everseen('AAAABBBCCDAABBB') --> A B C D
    # unique_everseen('ABBCcAD', str.lower) --> A B C D
    seen = set()
    seen_add = seen.add
    if key is None:
        for element in filterfalse(seen.__contains__, iterable):
            seen_add(element)
            yield element
    else:
        for element in iterable:
            k = key(element)
            if k not in seen:
                seen_add(k)
                yield element

def partition(iterable, predicate):
    """Divide the iterable into two iterables according to the predicate.

    >>> evens, odds = partition(range(10), lambda x: not x % 2)
    >>> list(evens)
    [0, 2, 4, 6, 8]
    >>> list(odds)
    [1, 3, 5, 7, 9]
    """
    t1, t2 = tee(iterable)
    return filter(predicate, t1), filterfalse(predicate, t2)

def unique(*iterables, key=None):
    """Yield unique elements, preserving order.

    >>> ''.join(unique('AAAABBBCCDAABBB'))
    'ABCD'
    >>> ''.join(unique('AAAA', 'BBBC', 'CDA', 'ABBB'))
    'ABCD'
    >>> ''.join(unique('ABBCcAD', key=str.casefold))
    'ABCD'
    """
    combined = chain.from_iterable(iterables)
    yielded = set()
    # Avoid inner-loop name lookups
    already_yielded = yielded.__contains__
    remember = yielded.add

    if key is None:
        for element in filterfalse(already_yielded, combined):
            remember(element)
            yield element

    else:
        for element in combined:
            k = key(element)
            if not already_yielded(k):
                remember(k)
                yield element

def remove_duplicates(iterable, key=None):
    """
    Renvoie un generateur sur un iterable qui enleve tous les elements en double dans une liste, conservant l'ordre."""
    seen = set()
    seen_add = seen.add
    if key is None:
        for element in filterfalse(seen.__contains__, iterable):
            seen_add(element)
            yield element
    else:
        for element in iterable:
            k = key(element)
            if k not in seen:
                seen_add(k)
                yield element

def remove_duplicates(iterable, key=None):
    """
    Renvoie un generateur sur un iterable qui enleve tous les elements en double dans une liste, conservant l'ordre."""
    seen = set()
    seen_add = seen.add
    if key is None:
        for element in filterfalse(seen.__contains__, iterable):
            seen_add(element)
            yield element
    else:
        for element in iterable:
            k = key(element)
            if k not in seen:
                seen_add(k)
                yield element

def _parse_merged_entities(self):
        """set self._merged_entities to the longest possible(wrapping) tokens
        """
        self._merged_entities = list(filterfalse(
            lambda token: self._is_wrapped(token, self.entities),
            self.entities))

def _parse_all_merged_entities(self):
        """set self._all_merged_entities to the longest possible(wrapping)
        tokens including non-entity tokens
        """
        self._all_merged_entities = list(filterfalse(
            lambda token: self._is_wrapped(token, self.all_entities),
            self.all_entities))

def phase1(self): # Compute common names
        a = dict(zip(map(os.path.normcase, self.left_list), self.left_list))
        b = dict(zip(map(os.path.normcase, self.right_list), self.right_list))
        self.common = list(map(a.__getitem__, filter(b.__contains__, a)))
        self.left_only = list(map(a.__getitem__, filterfalse(b.__contains__, a)))
        self.right_only = list(map(b.__getitem__, filterfalse(a.__contains__, b)))

def _filter(flist, skip):
    return list(filterfalse(skip.__contains__, flist))


# Demonstration and testing.
#

def test_itertools_filterfalse(self):
        """
        Tests whether itertools.filterfalse is available.
        """
        from itertools import filterfalse
        not_div_by_3 = filterfalse(lambda x: x % 3 == 0, range(8))
        self.assertEqual(list(not_div_by_3), [1, 2, 4, 5, 7])

def test_install_aliases(self):
        """
        Does the install_aliases() interface monkey-patch urllib etc. successfully?
        """
        from future.standard_library import remove_hooks, install_aliases
        remove_hooks()
        install_aliases()

        from collections import Counter, OrderedDict   # backported to Py2.6
        from collections import UserDict, UserList, UserString

        # Requires Python dbm support:
        # import dbm
        # import dbm.dumb
        # import dbm.gnu
        # import dbm.ndbm

        from itertools import filterfalse, zip_longest

        from subprocess import check_output    # backported to Py2.6
        from subprocess import getoutput, getstatusoutput

        from sys import intern

        # test_support may not be available (e.g. on Anaconda Py2.6):
        # import test.support

        import urllib.error
        import urllib.parse
        import urllib.request
        import urllib.response
        import urllib.robotparser

        self.assertTrue('urlopen' in dir(urllib.request))

def riffle_shuffle(iterable, n=2):
    """Generator that performs a perfect riffle shuffle on the input, using a given number of subdecks."""
    return itertools.filterfalse(non, itertools.chain.from_iterable(zip(*list(itertools.zip_longest(*[iter(iterable)]*n)))))

# Mappings

def unique_everseen(iterable, key=None):
    seen = set()
    seen_add = seen.add
    if key is None:
        for element in filterfalse(seen.__contains__, iterable):
            seen_add(element)
            yield element
    else:
        for element in iterable:
            k = key(element)
            if k not in seen:
                seen_add(k)
                yield element

def unique_everseen(iterable, key=None):
    """
    The generator to list unique elements, preserving the order. Remember all
    elements ever seen. This was taken from the itertools recipes.

    Args:
        iterable: An iterable to process.
        key: Optional function to run when checking elements (e.g., str.lower)

    Returns:
        Generator: Yields a generator object.
    """

    seen = set()
    seen_add = seen.add

    if key is None:

        for element in filterfalse(seen.__contains__, iterable):

            seen_add(element)
            yield element

    else:

        for element in iterable:

            k = key(element)

            if k not in seen:

                seen_add(k)
                yield element

def unique_everseen(iterable, key=None):
    """
    The generator to list unique elements, preserving the order. Remember all
    elements ever seen. This was taken from the itertools recipes.

    Args:
        iterable: An iterable to process.
        key: Optional function to run when checking elements (e.g., str.lower)

    Returns:
        Generator: Yields a generator object.
    """

    seen = set()
    seen_add = seen.add

    if key is None:

        for element in filterfalse(seen.__contains__, iterable):

            seen_add(element)
            yield element

    else:

        for element in iterable:

            k = key(element)

            if k not in seen:

                seen_add(k)
                yield element

def __get_preview_window(self):
        return next(filterfalse(lambda x:
                                not x.options['previewwindow'],
                                self.vim.windows), None)

def __get_preview_window(self):
        return next(filterfalse(lambda x:
                                not x.options['previewwindow'],
                                self.vim.windows), None)

    # Needed for openable actions

def parse_lines(msg_list):
    msg_list = filterfalse(lambda x: '#' in x, msg_list)
    new_list = []
    for line in msg_list:
        try:
            new_list.append(parse_line(line))
        except (ValueError, TypeError):
            logger.debug('Error parsing {}'.format(line))
    return convert_to_df(new_list)

def partition(predicate, iterable):
    """Use a predicate to partition true and false entries.

    Reference
    ---------
    Python itertools documentation.
    """

    t1, t2 = tee(iterable)

    return filterfalse(predicate, t1), filter(predicate, t2)

def phase1(self): # Compute common names
        a = dict(zip(map(os.path.normcase, self.left_list), self.left_list))
        b = dict(zip(map(os.path.normcase, self.right_list), self.right_list))
        self.common = list(map(a.__getitem__, filter(b.__contains__, a)))
        self.left_only = list(map(a.__getitem__, filterfalse(b.__contains__, a)))
        self.right_only = list(map(b.__getitem__, filterfalse(a.__contains__, b)))

def _filter(flist, skip):
    return list(filterfalse(skip.__contains__, flist))


# Demonstration and testing.
#

def send_game_start(self, session):
        conn_in_room = itertools.filterfalse(
            lambda x: x.room is None or x.spectate is True,
            self.server.connections)

        conns = sorted(conn_in_room, key=lambda x: x.room)
        for room_id, room_conns in itertools.groupby(conns, key=lambda x: x.room):
            if not room_id:
                continue

            self.check_song_start(session, room_id, room_conns)