Consume multiple iterators, filling each when exhausted with the last value they produced.

zip_longest_last.py

def zip_longest_last(*args):
	"""Consume multiple iterators, filling each when exhausted with the last value they produced."""
	line = []
	# CREATE a list of iterators of iterable objects passed as args.
	iters = [iter(it) for it in args]
	active = len(iters)
	lasts = [None]*active
	# CREATE a generator that yields the last item forever.
	def take_last(index):
		while True:
			yield lasts[index]
	# MAIN LOOP.
	while True:
		# FOREACH iterator in the list.
		for n, it in enumerate(iters):
			try:
				# GET the value from the iterator.
				value = next(it)
			# CHECK if there are no elements left into the iterator.
			except StopIteration:
				# REPLACE the exhausted iterator with the generator
				# that yields forever the last element.
				iters[n] = take_last(n)
				# SET that last element to the value we have to yield.
				value = lasts[n]
				# DECREASE active iterators.
				active -= 1
				if active == 0:
					# EXIT if there are no more active iterators.
					return
			else:
				# SAVE the last element of this iterator.
				lasts[n] = value
			# ADD this element value to the current line of elements
			# we will yield.
			line.append(value)
		# YIELD the line of elements as a tuple.
		yield tuple(line)
		# CLEAR the line to make room for the next line.
		line = []

In [9]: list(zip_longest_repeating(a, b))                                  
Out[9]: 
[(1, 1),
 (2, 2),
 (3, 3),
 (4, 4),
 (4, 5),
 (4, 6),
 (4, 7),
 (4, 8),
 (4, 9),
 (4, 0)]

In [10]: list(zip_longest_last(a, b))
Out[10]: 
[(1, 1),
 (2, 2),
 (3, 3),
 (4, 4),
 (4, 5),
 (4, 6),
 (4, 7),
 (4, 8),
 (4, 9),
 (4, 0)]

In [11]: %timeit list(zip_longest_repeating(a, b))                         
18.8 µs ± 988 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [12]: %timeit list(zip_longest_last(a, b))                              
19.6 µs ± 1.17 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Yours is slightly slower than mine, the reason becomes clear with disassembly (dis module, dis function within): mine contains 25 instructions, yours compiles to 40. There are some minor comments relating to the code itself, as well.

Line 28 is ≅ to the test on line 20 of mine. I do not make a numerical comparison, I only check if the value is "truthy". The resulting bytecode does not contain the value being compared against [edit to add: and skips "comparison" entirely]:

 20          94 LOAD_FAST                3 (count)
             96 POP_JUMP_IF_TRUE       106

Versus:

 28         120 LOAD_FAST                3 (active)
            122 LOAD_CONST               7 (0)
            124 COMPARE_OP               2 (==)
            126 POP_JUMP_IF_FALSE      136

Thanks! 👍