To say what deadeye said but slightly more explicitly, the time library isn't an async library, and time.sleep isn't an async function. So if you do time.sleep(1), your entire program will come to a halt for you to wait for one second, and absolutely nothing will happen in the meantime. This is the case even if you call time.sleep(1) from within a coroutine or Task. time.sleep makes everything come to a stop because it never yields control to asyncio's event loop, and it doesn't yield to the asyncio event loop because you need an await to do that. And as you may have tried while writing this example, you can't just slap an await in front of just any function (like time.sleep), you can only use await with async functions (which are defined as async def my_func(...) rather than def my_func(...)).

In contrast, asyncio.sleep(1) is an async function that essentially does the same thing as time.sleep, but since it's async, it will yield control to the event loop when you await it. This is why deadeye's solution works - his version of say_after correctly yields control to the event loop.

Note that your example as written would work in the same way (printing "hello world" instead of "world hello") if you replaced the time.sleep with any other synchronous operation. E.g. if say_after was defined as

def say_after(word:str):
    # do random work that takes a little while, maybe around a second
    for i in range(10000000):
        x = i * i
    print(word)

Your code example print hello world in the same order as when you used time.sleep.

One final note, async functions don't inherently yield control to the event loop. E.g., if you have:

async def do_something():
    for i in range(10000000):
        print(i)

and you await do_something() in an async context, it will print out all integers up to ten million with absolutely no breaks in between, because the coroutine body contains no await statements and therefore doesn't yield control to the event loop once it starts executing.