I think this issue seriously needs some attention.
(Found this, not sure whether it helps: https://stackoverflow.com/questions/37289082/redirect-stdout-stderr-from-python-embedded-in-net-application-to-text-box)

EDIT 12/19/23: I noticed that when running the application directly from cmd line with dotnet run that all the python print statements were showing by default, w/o the hack below. Not sure why they aren't showing in my IDE console window...

EDIT 1/24/24: Dug a little further and noticed that when debugging directly from VS Code & the C# dev kit extension using the internalConsole (i.e. VS Code's built-in debug console) setting, then python print statement output wouldn't show immediately in the debug console, however they would end up showing in console output eventually (if program ran long enough). Not sure what was holding it back exactly, but I noticed that if I switched to the integratedTerminal or externalTerminal options, then all output was shown just fine (w/o the hack below).

Since regular C# Console.WriteLine output shows just fine either way, I'm really not sure where the issue lies (VS Code, extension, or PythonNet directly), but I'm perfectly fine with using the integratedTerminal for my situation anyways. So ultimately, the solution below is not needed since PythonNet does seem to write to the .NET output stream.

OP:

I ended up putting together the below code instead of using the sample code shown in the above SO post, mostly because I wanted a global option that didn't require every python call wrapped in a context. Additionally, the sample code in that SO post will only show the console output after the python script has finished executing, while the below should print it out in real time during live execution (i.e. long running processes or while-loop infinite loops). This also seems to work when running script files via scope.Execute(PythonEngine.Compile(code, filename)).

using Python.Runtime;

Console.WriteLine("Hello, World!");

Runtime.PythonDLL = "python312.dll";

PythonEngine.Initialize();

using var _ = Py.GIL();

using var scope = Py.CreateScope();

scope.Exec(
"""
import sys

class NetConsole(object):
    def __init__(self, writeCallback):
        self.terminal = sys.stdout
        self.writeCallback = writeCallback

    def write(self, message):
        self.terminal.write(message)
        self.writeCallback(message)

    def flush(self):
        # this flush method is needed for python 3 compatibility.
        # this handles the flush command by doing nothing.
        # you might want to specify some extra behavior here.
        pass

def setConsoleOut(writeCallback):
    sys.stdout = NetConsole(writeCallback)
"""
);

dynamic setConsoleOutFn = scope.Get("setConsoleOut");

var writeCallbackFn = (string message) => {
    if (message != "\n")
        Console.Write("[Py]: ");

    Console.Write(message);
};

setConsoleOutFn(writeCallbackFn);

scope.Eval("print('hello world')");

.NET Console output:

Hello, World!
[Py]: hello world

Hope this helps someone else!

Building off of @ipavel83 's answer, you can even implement stdout as a C# class to avoid embedding large strings of Python code like that.

sealed class ConsoleStdio
{
    public void write(string s) => Console.WriteLine(s);

    // Doesn't seem to be needed in my case
    //public void flush() { }
}

using var scope = Py.CreateScope();

// Redirect stdio
dynamic sys = scope.Import("sys");
sys.stdout = new ConsoleStdio();
sys.stderr = new ConsoleStdio();

// Exec the user's code
scope.Exec("print('hello world')");