Question: Imagine you need to count number of `iterable` elements that satisfy some `criteria` - is there is a more good looking way to do this?
It's python3 of course. But 2 is fine too.
I can't find anything suitable in `collections` or `itertools` python modules or in built-ins.

Answer: 
Try the `quantify` recipe from `itertools` [recipes](https://docs.python.org/3/library/itertools.html#itertools-recipes):

```
def quantify(iterable, pred=bool):
    "Count how many times the predicate is true"
    return sum(map(pred, iterable))

```

[`more_itertools`](https://github.com/erikrose/more-itertools) already implements this recipe, so it is even more compact:

```
>>> import more_itertools as mit

>>> iterable = [True, False, True, True]
>>> mit.quantify(iterable)
3

```

For comparison:

```
>>> #len(list(filter(lambda x: criteria, iterable)))
>>> len(list(filter(lambda x: x is True, iterable)))
3

```

---

**Performance**

```
# A: len(list(filter(lambda x: criteria, iterable)))
>>> %timeit -n 1000000 len(list(filter(lambda i: i is True, iterable)))
1000000 loops, best of 3: 2.48 µs per loop

# B: quantify(iterable, pred=condition)
>>> %timeit -n 1000000 mit.quantify(iterable)
1000000 loops, best of 3: 1.87 µs per loop

# C: ilen(item for item in iterable if condition)
>>> %timeit -n 1000000 mit.ilen(i for i in iterable if i is True)
1000000 loops, best of 3: 5.27 µs per loop

# D: len([item for item in iterable if condition])
>>> %timeit -n 1000000 len([i for i in iterable if i is True])
1000000 loops, best of 3: 973 ns per loop

# E: sum(1 for _ in iterable if condition)
>>> %timeit -n 1000000 sum(1 for i in iterable if i is True)
1000000 loops, best of 3: 1.34 µs per loop

```

* **A**: *control* - author's example
* **B**: *faster* - `quantify`, `itertools` recipe
* **C**: *slowest* - generator expression, uses `more_itertools.ilen` to evaluate
* **D**: *fastest* - list comprehension
* **E**: *faster* - generator expression, `sum(1 for _ in ...)` idiom

While `more_itertools.quantify` is concise, the idiomic generator expression is on par if not faster. However, classic list comprehensions (first suggested by @宏杰李) are the best performers.

See also a [thread](https://mail.python.org/pipermail//python-ideas/2014-October/029650.html) on extending `len()` to generators.
> 
> List comprehensions provide a concise way to create lists. Common
>  applications are to make new lists where each element is the result of
>  some operations applied to each member of another sequence or
>  iterable, or to create a subsequence of those elements that satisfy a
>  certain condition.
> 
> 
> 

```
>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

```

> 
> Note that this creates (or overwrites) a variable named x that still
>  exists after the loop completes. We can calculate the list of squares
>  without any side effects using:
> 
> 
> 

```
squares = list(map(lambda x: x**2, range(10)))

```

> 
> or, equivalently:
> 
> 
> 

```
squares = [x**2 for x in range(10)]

```

than just put you conditon in the the if statment like this

```
>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

```

you got a list of elements which meet the condition, and you can use `len(lsit_)` to count the elements

[List Comprehension Document](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions)