I think this is largely (but not entirely) a matter of taste.

Let's compare directly:

```python
if frames == len(out):
    return out
elif fill_value is None:
    return out[:frames]
else:
    out[frames:] = fill_value
    return out
```

vs.

```python
if len(out) > frames:
    if fill_value is None:
        out = out[:frames]
    else:
        out[frames:] = fill_value

return out
```

Both are functionally equivalent (if I'm not mistaken) except in the case that `len(out) < frames`, which I guess can never happen (at least it shouldn't).
I think the nested logic actually *helps* understanding, in your suggestion the nested logic is somehow "folded into" the `elif` condition.
I think the second example follows exactly my understanding (but probably only mine) about what's going on:

1. we have `out`
1. if a certain condition is met (`out` is larger than `frames`), we change `out`, otherwise we don't do anything with it
  1. this one condition has a subcondition, which decides how exactly we change `out` (by either "cutting off" the rest or by filling it with something
1. we return `out`

I think this is a very common pattern: changing something if a certain condition is met, doing nothing if not.
This is also the reason why the `else` part of an `if` statement is optional in probably all languages that have an `if` statement [citation needed].

In addition to having a less clear (IMHO) logic, the first example has also a code smell because common functionality (`return`ing something) is repeated in each branch.