Python 3's map returns a map object, which you need to convert to list explicitly:

f1_b = list(map(lambda x: list(map(lambda t: t.strip(), x.split(',', 1))), lst))

Though in most cases you should prefer list comprehensions to map calls:

f1_a = [[t.strip() for t in x.split(',', 1)] for x in lst]

One-liner with mix of map and listcomp:

a = [map(float, suba) for suba in a]  # Only works on Py2

Or variants:

# Both of the below work on Py2 and Py3
a = [list(map(float, suba)) for suba in a]
a = [[float(x) for x in suba] for suba in a]

Choose based on your personal preference and target Python version. For large nested lists on CPython 2, the first variant is probably the fastest (if the inner lists are huge, it avoids lookup overhead to get the float constructor and byte code execution for the inner lists), and the list wrapped equivalent might eventually win on CPython 3; for small nested lists on all versions, the nested list comprehensions is usually going to be the fastest.

TL;DR: With current Python typing support, this is probably just impossible. Sorry.

First of all, you definitely can't write a type hint that preserves the exact structure of the input. That would rely on structure-preserving type hints for flat lists, which don't exist (and would run counter to the purpose of a list if they did).

That means the best you can hope for is an annotation that preserves union types for each nesting level. This is already suboptimal because if one level contains, say, both lists and tuples, every element in that level would have a type of list | tuple, which discards information. The type mappings would look something like this:

list[A | list[A | list[A]]] -> list[B | list[B | list[B]]]
list[A | tuple[A, A | list[A]] -> list[B | tuple[B, B | list[B]] 

Unfortunately, even this probably isn't doable. In order for this to work, you'd need to use nested generics like your "parameterize one variable by another" attempt, which I'll reproduce here:

def nested_mapA, B, C: NestedStructure -> C[B]: ...

Nested generics like C[A] are "higher-kinded types", which just don't exist in Python. There is an open feature request on GitHub that's still seeing some activity, but it hasn't even been formulated into a PEP yet.

I don't think there's a way to do this without higher-kinded types:

1. The original leaf type needs a TypeVar since it defines an abstract relationship between the callback and parameter types.
2. The new leaf type needs a TypeVar since it defines an abstract relationship between the callback and return types.
3. The structure of the nested iterable needs a TypeVar since it defines an abstract relationship between the parameter and return types.
4. These three TypeVars must be separate because none can be inferred from the others.
5. It must be possible to narrow one abstract type (the iterable) based on another abstract type (the leaves).

The final requirement in particular basically forces you to use nested generics.

Use just a list-comprehension that sets element based on conditions:

def rreplace(lst, l, u):
    return [l if x < l else u if x > u else x for x in lst]

A = [0,1,2,3,4,5,6,7,8,9,10]
print(rreplace(A, 2, 8))

# [2, 2, 2, 3, 4, 5, 6, 7, 8, 8, 8]

You can use the dict.get(key, default) method to provide a default value instead of catching an Exception. This makes your computation a single expression, which is good for further inlining:

for elem in window:
    index = model.vocab.get(elem, unk).index
    window2index.append(index)

Which can be rewritten as:

window2index = [model.vocab.get(elem, unk).index for elem in window]

Which is faster in Cpython, and fairly straightforward.

Now, of course, you have a similar pattern for sent, and a similar pattern for input:

input2index = [EXPR-USING-sent for sent in input]

sent2index = [EXPR-USING-window for window in sent]

window2index = ... see above ...

So you can stack them all together as:

unk = model.vocab['unk']
input2index = [EXPR-USING-sent for sent in input]
return input2index

which becomes:

unk = model.vocab['unk']
input2index = [[EXPR-USING-window for window in sent] for sent in input]
return input2index

which becomes:

unk = model.vocab['unk']
input2index = [[[model.vocab.get(elem, unk).index
                for elem in window]
                for window in sent] 
                for sent in input]
return input2index