为何使用Python的open()打开文件描述符？该方式相较传路径字符串有何优势？

Great question! Let's walk through the key practical scenarios where passing a file descriptor to open() makes more sense than using a path:

• Work with already opened streams/files
  Sometimes you already have a file descriptor obtained from other system calls (like os.open(), subprocess.Popen's stdout/stderr pipes, or even low-level library functions). Wrapping this FD with open() lets you convert it into a familiar Python file-like object, so you can use convenient methods like read(), write(), or context managers (with statements) instead of dealing with raw OS-level FD operations. For example:

  import os
  # Get a raw file descriptor via os.open
  fd = os.open("example.txt", os.O_RDONLY)
  # Wrap it into a file-like object
  with open(fd, 'r', closefd=True) as f:
      print(f.read())
  

• Share file state across multiple handlers
  When you use the same FD to create multiple file-like objects, they share the same file pointer position and state. This is useful if you need different parts of your code to interact with the same open file without syncing separate file handles. If you opened the same path twice, each handle would have its own independent file pointer, which might not be what you want.

• Interact with non-path-based streams
  Not all file descriptors map to regular files on disk. Things like pipes, sockets, terminal devices (e.g., /dev/tty), or special files like /dev/null often are accessed via FDs, and might not have a straightforward path you can pass to open() (or opening via path might not give you the same stream as the existing FD). Wrapping these FDs lets you use Python's IO APIs on these special streams.

• Fine-grained control over FD lifecycle
  The closefd parameter gives you control over whether closing the Python file-like object also closes the underlying FD. If you need the FD to remain open for other parts of your code (or even child processes), you can set closefd=False. This is handy when you're managing FDs across different components without wanting to accidentally close a resource still in use.

Also, to confirm your observation: the file descriptors passed to open() are always from the current Python process—each process has its own independent FD table, so you can't directly reference FDs from another process unless you use inter-process communication mechanisms to pass them (a more advanced use case not directly handled by open() alone).

内容的提问来源于stack exchange，提问作者y_fd