Идиоматический Python has_one

Однако не уверен, что это лучше, чем версии, которые вы предложили...

Если предикат гарантированно возвращает только True/False, то

sum(map(predicate, seq)) == 1

подойдет (хотя он не остановится на втором элементе)

Как насчет вызова any дважды на итераторе (Python 2.x и 3.x совместим)?

>>> def has_one(seq, predicate=bool):
...     seq = (predicate(e) for e in seq)
...     return any(seq) and not any(seq)
... 
>>> has_one([])
False
>>> has_one([1])
True
>>> has_one([0])
False
>>> has_one([1, 2])
False

any будет принимать не более один элемент, который оценивается как True от итератора. Если это удается в первый раз и терпит неудачу во второй раз, то только один элемент соответствует предикату.

Изменить: я вижу, что Роберт Россни предлагает обобщенную версию, которая проверяет, точно ли n соответствуют предикату. Позвольте мне присоединиться к веселью, используя all:

>>> def has_n(seq, n, predicate=bool):
...     seq = (predicate(e) for e in seq)
...     return all(any(seq) for _ in range(n)) and not any(seq)
... 
>>> has_n(range(0), 3)
False
>>> has_n(range(3), 3)
False
>>> has_n(range(4), 3)
True
>>> has_n(range(5), 3)
False

Возможно, что-то подобное вам больше по вкусу?

def has_one(seq,predicate=bool):
    nwanted=1
    n=0
    for item in seq:
        if predicate(item):
            n+=1
            if n>nwanted:
                return False

    return n==nwanted

Это похоже на пример понимания списка, но требует только одного прохода по одной последовательности. По сравнению со второй функцией has_one, как и код понимания списка, она легче обобщается на другие подсчеты. Я продемонстрировал это (надеюсь, без ошибок...), добавив переменную для количества требуемых элементов.

Мне понравился ответ Stephan202, но этот мне нравится немного больше, хотя это две строки вместо одной. Мне это нравится, потому что это такое же безумие, но немного более подробно о том, как работает это сумасшествие:

def has_one(seq):
    g = (x for x in seq)
    return any(g) and not any(g)

Изменить:

Вот более обобщенная версия, поддерживающая предикат:

def has_exactly(seq, count, predicate = bool):
    g = (predicate(x) for x in seq)
    while(count > 0):
        if not any(g):
            return False
        count -= 1
    if count == 0:
        return not any(g)

Как насчет ...

import functools
import operator

def exactly_one(seq):
    """
    Handy for ensuring that exactly one of a bunch of options has been set.
    >>> exactly_one((3, None, 'frotz', None))
    False
    >>> exactly_one((None, None, 'frotz', None))
    True
    """
    return 1 == functools.reduce(operator.__add__, [1 for x in seq if x])

Смотри, Ма! Никакого rtfm("itertools"), никакой зависимости от predicate(), возвращающего логическое значение, минимальная оценка, просто работает!

Python 1.5.2 (#0, Apr 13 1999, 10:51:12) [MSC 32 bit (Intel)] on win32
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> def count_in_bounds(seq, predicate=lambda x: x, low=1, high=1):
...     count = 0
...     for item in seq:
...         if predicate(item):
...             count = count + 1
...             if count > high:
...                 return 0
...     return count >= low
...
>>> seq1 = [0, 0, 1, 0, 1, 0, 1, 0, 0, 0]
>>> count_in_bounds(seq1)
0
>>> count_in_bounds(seq1, low=3, high=3)
1
>>> count_in_bounds(seq1, low=3, high=4)
1
>>> count_in_bounds(seq1, low=4, high=4)
0
>>> count_in_bounds(seq1, low=0, high=3)
1
>>> count_in_bounds(seq1, low=3, high=3)
1
>>>

Вот измененный ответ @Stephan202:

from itertools import imap, repeat

def exactly_n_is_true(iterable, n, predicate=None):
    it = iter(iterable) if predicate is None else imap(predicate, iterable)
    return all(any(it) for _ in repeat(None, n)) and not any(it)

Отличия:

1. predicate() по умолчанию — Нет. Значение такое же, как и для встроенных функций filter() и itertools.ifilter() из stdlib.

2. Более явные имена функций и параметров (это субъективно).

3. repeat() позволяет использовать большие n.

Пример:

if exactly_n_is_true(seq, 1, predicate):
   # predicate() is true for exactly one item from the seq

Это и это простые решения со счетным циклом, безусловно, самые ясные.

Ради интереса, вот вариация на тему any(g) and not any(g), которая на первый взгляд выглядит менее волшебной, но на самом деле она такая же хрупкая, когда дело доходит до ее отладки/модификации (вы не можете изменить порядок, вы должны понимать, как короткое замыкание and передает один итератор между двумя потребителями короткого замыкания...).

def cumulative_sums(values):
    s = 0
    for v in values:
        s += v
        yield s

def count_in_bounds(iterable, start=1, stop=2):
    counter = cumulative_sums(bool(x) for x in iterable)
    return (start in counter) and (stop not in counter)

Тривиально также взять предикат вместо bool, но я думаю, что лучше следовать any() и all(), оставляя это вызывающей стороне - при необходимости легко передать выражение генератора.

Взятие произвольного [start, stop) — приятный бонус, но он не такой общий, как хотелось бы. Заманчиво передать stop=None для подражания, например. any(), который работает, но всегда потребляет весь ввод; правильная эмуляция довольно неудобна:

def any(iterable):
  return not count_in_bounds(iterable, 0, 1)

def all(iterable):
  return count_in_bounds((not x for x in iterable), 0, 1)

Взять переменное количество границ и указать, какие из них должны возвращать True/False, выйдет из-под контроля.
Возможно, простой счетчик с насыщением — лучший примитив:

def count_true(iterable, stop_at=float('inf')):
    c = 0
    for x in iterable:
        c += bool(x)
        if c >= stop_at:
            break
    return c

def any(iterable):
    return count_true(iterable, 1) >= 1

def exactly_one(iterable):
    return count_true(iterable, 2) == 1

def weird(iterable):
    return count_true(iterable, 10) in {2, 3, 5, 7}

all() по-прежнему требует отрицания входных данных или соответствующего помощника count_false().