Update: Who would have thought @StefanPochmann could challenge my well-crafted response? While it may not be crucial to the original question, it's interesting to note that 'zip' operates on pairs of elements. Therefore, even if you pause alter at an odd iteration, 'y' will already be printed.

For those interested in Stefan's alternative solution:

>>> alter = map(next, itertools.cycle((foo1(), foo2())))

A rather smart approach, I must say.

Update ends

If you'd like, you can turn the functions into generators and then zip them together.

>>> import itertools as it
>>>
>>> def foo1():
...     while True:
...         print("x")
...         yield None
... 
>>> def foo2():
...     while True:
...         print("y")
...         yield None
... 
>>> alter = it.chain.from_iterable(zip(foo1(), foo2()))
>>> while True:
...     next(alter)

x
y
x
y
...

or:

>>> for a in alter:
...     pass

x
y
x
y
...

In my opinion, I really like the approach taken by Paul Panzer with using `itertools`. However, if feasible, I highly recommend removing the "infinite loop" from these functions and placing it in a separate "driver" function that can call them alternately.

def f1():
    print('x')

def f2():
    print('y')

def driver():
    while True:
        f1()
        f2()

I understand that this may not work for every scenario, but it can definitely result in better overall design if possible.

If you're looking to accomplish your goal using the functions provided, unfortunately there isn't a direct way to do so. However, there are alternate methods that could potentially achieve similar results, depending on how flexible you can be with modifying your existing code.

One approach is to introduce threads for quasi-parallel execution. While Python doesn't truly allow concurrent running of multiple Python code snippets simultaneously due to the Global Interpreter Lock (GIL), this method might suffice for your specific requirements. Keep in mind though, your current functions may not perform optimally with threading as the GIL can cause one thread to frequently block the other, resulting in sequences like many 'x's followed by many 'y's due to irregular GIL swapping.

Another option is leveraging multiprocessing for true parallelism. This should offer better interleaving of your functions compared to threading, although exact timing consistency between process swaps might still vary. Consequently, instead of always obtaining an "xyxyxyxy" sequence, you could end up with variations like "xyxxyyxy" based on factors such as OS, CPU, and system load.

To delve into solutions requiring adjustments to the functions themselves, one straightforward route involves merging them into a single function:

def combined_foo():
    while True:
        print('x')
        print('y')

An alternate strategy is transforming the functions into generators which can then be amalgamated utilizing zip:

def gen_foo1():
    while True:
        yield 'x'

def gen_foo2():
    while True:
        yield 'y'

You can iterate through these generators as follows:

for x, y in zip(gen_foo1(), gen_foo2()):
    print(x)
    print(y)

Or, if you prefer a unified iterable output:

for value in itertools.chain.from_iterable(zip(gen_foo1(), gen_foo2())):
    print(value)

Based on your explanation, it seems that you are looking to alternate between two functions rather than have them run simultaneously. This concept is known as co-operative multitasking.

You can achieve this by turning each function into a coroutine. In Python, you can do this by converting them into generator functions, which involves adding a yield statement at the appropriate location. This allows each function to pause execution until next() is called on them again.

The main thing to remember is that each generator function needs to be "primed" when first called (the code inside is not executed until then). The initial call to next() after calling the function advances its execution to the first yield statement.

Here's an example:

def foo1():
    while True:
        yield
        print("x")

def foo2():
    while True:
        yield
        print("y")

# Usage example.
def process():
    f1 = foo1()
    next(f1)  # Prime the generator.
    f2 = foo2()
    next(f2)  # Prime the generator.
    while True:
        next(f1)
        next(f2)


process()

Output:

x
y
x
y
x
...

If you anticipate using this frequently, you can create a decorator to automatically prime generator functions used as coroutines (inspired by a tutorial from David Beazley at Pycon 2009 titled Curious Course on Coroutines and Concurrency).

def coroutine(func):
    """ Decorator that primes coroutine functions automatically. """
    def start(*args,**kwargs):
        cr = func(*args,**kwargs)
        next(cr)
        return cr

    return start

@coroutine
def foo1():
    while True:
        yield
        print("x")

@coroutine
def foo2():
    while True:
        yield
        print("y")

# Usage example.
def process():
    f1, f2 = foo1(), foo2()  # Automatically primed.
    for _ in range(10):
        next(f1)
        next(f2)

Here's my personal method for achieving this task, although there may be more efficient ways to do it.

def foo(i):
    while(True):
       i += 1
       if(i%2 == 0):
            print('x')
       else:
            print('y')

In this code snippet, the variable i acts as an iterator. It is incremented by 1 each time with i+= 1. Then, we check whether i is even or odd, causing it to alternate between printing 'x' for even numbers and 'y' for odd numbers. I hope this explanation clarifies things!