Format a string to have the same spaces as another string in python

Rather than trying to do this by mutating the string, I'd suggest doing it by iterating over both strings in parallel and building a new string:

>>> def func(a, b):
...     j = 0
...     ret = ""
...     for x in a:
...         if x.isspace():
...             ret += x
...         else:
...             ret += b[j]
...             j += 1
...     return ret
...
>>> func("foofoo foo fo o", "abcabcabcabc")
'abcabc abc ab c'

Maybe something like this:

foo = "foofoo foo fo o"
abc = "abcabcabcabc"

def manip(origin: str, pattern: str) -> str:
	comp: str = ""
	i: int = 0
	for p in pattern:
		comp += " " if p == " "	else origin[i]
		if p != " ": i += 1
	return comp

print(manip(abc,foo))

You could make an iterator out of the second string and yield values where s1 is not a space otherwise the next letter:

foo = "foofoo foo fo o"
abc = "abcabcabcabc"


def match_spaces(s1, s2):
    it = iter(s2)
    return ' '.join(l if l.isspace() else next(it) for l in s1)

match_spaces(foo, abc)
# 'a b c a b c   a b c   a b   c'

You can use re.finditer() to find the position of spaces, and then just build the string from the indices:

import re
from itertools import tee

foo = "foofoo foo fo o"
abc = "abcdefghijkl"

spans = []
pos = 0

a_start, a_end = (0, 0)
for m in re.finditer(" ", foo): 
    b_start, b_end = m.span()
    spans.append(abc[pos:pos + b_start - a_end])
    spans.append(m.group())
    pos += b_start - a_end
    a_start, a_end = b_start, b_end
    
spans.append(abc[pos:])
print("".join(spans))

Alternatively, if you can express the split pattern as a negative regex, you can express this very elegantly using itertools instead:

import re
from itertools import chain, tee, accumulate, pairwise

foo = "foofoo foo fo o"
abc = "abcdefghijkl"

matches = list(re.finditer("[^ ]+", foo))
lens = (m.end() - m.start() for m in matches)
accs = accumulate(lens, initial=0)
indices = pairwise(accs)
result = " ".join([abc[a:z] for m, (a, z) in zip(matches, indices)])
print(result)

pairwise is available on Python 3.10 upwards, accumulate is available since Python 3.2, but the initial argument is new in Python 3.8. Refer to itertools documentations for equivalent implementation suitable for older Python.