# How to filter arrays by number of items#

```import awkward as ak
```

In general, arrays are filtered using NumPy-like slicing. Numerical values can be filtered by numerical expressions in a way that is very similar to NumPy:

```array = ak.Array([
[[0, 1.1, 2.2], []], [[3.3, 4.4]], [], [[5.5], [6.6, 7.7, 8.8, 9.9]]
])
```
```array[array > 4]
```
```[[[], []],
[[4.4]],
[],
[[5.5], [6.6, 7.7, 8.8, 9.9]]]
-------------------------------
type: 4 * var * var * float64```

but it’s also common to want to filter arrays by the number of items in each list, for two reasons:

• to exclude empty lists so that subsequent slices can select the item at index `0`,

• to make the list lengths rectangular for computational steps that require rectangular array (such as most forms of machine learning).

There are two functions that provide the lengths of lists: `ak.num()` and `ak.count()`. To filter arrays, you’ll most likely want `ak.num()`.

## Use `ak.num`#

`ak.num()` can be applied at any `axis`, and it returns the number of items in lists at that `axis` with the same shape for all levels above that `axis`.

```ak.num(array, axis=0)
```
```array(4)
```
```ak.num(array, axis=1)   # default
```
```[2,
1,
0,
2]
---------------
type: 4 * int64```
```ak.num(array, axis=2)
```
```[[3, 0],
[2],
[],
[1, 4]]
---------------------
type: 4 * var * int64```

Thus, if you want to select outer lists of `array` with length 2, you would use `axis=1`:

```array[ak.num(array) == 2]
```
```[[[0, 1.1, 2.2], []],
[[5.5], [6.6, 7.7, 8.8, 9.9]]]
-------------------------------
type: 2 * var * var * float64```

And if you want to select inner lists of `array` with length greater than 2, you would use `axis=2`:

```array[ak.num(array, axis=2) > 2]
```
```[[[0, 1.1, 2.2]],
[],
[],
[[6.6, 7.7, 8.8, 9.9]]]
-----------------------------
type: 4 * var * var * float64```

The ragged array of booleans that you get from comparing `ak.num()` with a number is exactly what is needed to slice the array.

## Don’t use `ak.count`#

By contrast, `ak.count()` returns structures that you can’t use this way (for all but `axis=-1`):

```ak.count(array, axis=None)   # default
```
```10
```
```ak.count(array, axis=0)
```
```[[3, 2, 1],
[1, 1, 1, 1]]
---------------------
type: 2 * var * int64```
```ak.count(array, axis=1)
```
```[[1, 1, 1],
[1, 1],
[],
[2, 1, 1, 1]]
---------------------
type: 4 * var * int64```
```ak.count(array, axis=2)   # equivalent to axis=-1 for this array
```
```[[3, 0],
[2],
[],
[1, 4]]
---------------------
type: 4 * var * int64```

Also, `ak.num()` can be used on arrays that contain records, whereas `ak.count()` (like other reducers), can’t.

As a reducer, `ak.count()` is intended to be used in a mathematical formula with other reducers, like `ak.sum()`, `ak.max()`, etc. (usually as a denominator). Its `axis` behavior matches that of other reducers, which is important for the shapes of nested lists to align.