Filter on exception from generator

I would like to iterate over a generator/iterator and pass the value produced to the function.
The function can either return a new value or raise an error.
I then need to return the value or skip on error.

I came up with the following code:

def yield_or_skip(iter_: Iterable, func: Callable, skip_on_errors: Iterable[Type[Exception]]) -> Iterator:
    skip_on_errors = set(skip_on_errors)
    for item in iter_:
        try:
            yield func(item)
        except Exception as e:
            if type(e) in skip_on_errors:
                continue
            raise

It seems to work, but I was wondering if there is a better way to do this?

Note: it has to be an iterator/generator, I can't gather results in a list.

Maybe suppress?

from contextlib import suppress

def yield_or_skip(iter_: Iterable, func: Callable, skip_on_errors: Iterable[Type[Exception]]) -> Iterator:
    skipper = suppress(*skip_on_errors)
    for item in iter_:
        with skipper:
            yield func(item)

Demo:

for y in yield_or_skip([2, 0, 3], lambda x: 1/x, [ZeroDivisionError]):
    print(y)

print()

for y in yield_or_skip([2,0,3], lambda x: 1/x, [ValueError]):
    print(y)

Output (Attempt This Online!):

0.5
0.3333333333333333

0.5
Traceback (most recent call last):
  File "/ATO/code", line 26, in <module>
    for y in yield_or_skip([2,0,3], lambda x: 1/x, [ValueError]):
  File "/ATO/code", line 19, in yield_or_skip
    yield func(item)
  File "/ATO/code", line 26, in <lambda>
    for y in yield_or_skip([2,0,3], lambda x: 1/x, [ValueError]):
ZeroDivisionError: division by zero

more_itertools.map_except does that job. You can use it instead, or use it to implement yours (Attempt This Online!):

from more_itertools import map_except

def yield_or_skip(iter_: Iterable, func: Callable, skip_on_errors: Iterable[Type[Exception]]) -> Iterator:
    return map_except(func, iter_, *skip_on_errors)

Or adapt its source code:

    for item in iterable:
        try:
            yield function(item)
        except exceptions:
            pass