Seite 2 von 2

Re: Verständnisfrage zu Bitweiser-Operatoren

Verfasst: Freitag 24. April 2026, 18:39
von snafu
@Sirius3: Das mag jetzt exakt wie zip() sein, ist aber übelster Spaghetti-Code. IMHO erfüllt zip() am besten seinen Zweck, wenn es ohne Fehlermeldung alle "überflüssigen" Elemente ignoriert. Wenn man die Fehlerbehandlung aber wirklich so feingliederig haben möchte, dann sollte man sie zumindest aus der eigentlichen Funktion herausziehen.

Re: Verständnisfrage zu Bitweiser-Operatoren

Verfasst: Freitag 24. April 2026, 19:53
von Sirius3
Besser?

Code: Alles auswählen

def handle_error(index):
    if index == 0:
        for index, it in enumerate(iterators):
            try:
                next(it)
                break
            except StopIteration:
                pass
        else:
            return
        compares = "longer"
    else:
        compares = "shorter"
    end_index = "" if index == 1 else f"-{index}"
    raise ValueError(f"zip() argument {index + 1} is {compares} than arguments 1{end_index}")


def zip_it(*iterables, strict=False):
    iterators = [iter(it) for it in iterables]
    if iterators:
        while True:
            try:
                zipped = []
                for it in iterators:
                    zipped.append(next(it))
            except StopIteration:
                if strict:
                    handle_error(iterators, len(zipped))
                break
            else:
                yield tuple(zipped)

Re: Verständnisfrage zu Bitweiser-Operatoren

Verfasst: Samstag 25. April 2026, 03:27
von snafu
Wenn ich das strict-Argument einbaue und die Fehlerbehandlung übernehme:

Code: Alles auswählen

def count_exhausted(iterators):
    exhausted = []
    for it in iterators:
        try:
            next(it)
        except StopIteration:
            exhausted.append(it)
    return len(exhausted)

def build_exception(relation, position):
    maybe_plural = "s 1-" if position > 2 else " "
    return ValueError(
        f"zip_it() argument {position} is {relation} than "
        f"argument{maybe_plural}{position - 1}"
    )

def zip_it(*iterables, strict=False):
    if not iterables:
        return
    iterators = [iter(it) for it in iterables]
    while True:
        zipped = tuple(map(next, iterators))
        if len(zipped) < len(iterators):
            if not strict:
                break
            if zipped:
                raise build_exception("shorter", len(zipped) + 1)
            num_exhausted = count_exhausted(iterators)
            if num_exhausted == len(iterators):
                break
            raise build_exception("longer", num_exhausted + 1)
        yield zipped
Auf enumerate() hatte ich verzichtet, um konsistent mit dem Vorgehen bei map() zu bleiben.