Python | os.mkfifo() method

OS module in Python provides functions for interacting with the operating system. OS comes under Python’s standard utility modules. This module provides a portable way of using operating system dependent functionality. os.mkfifo() method in Python is used to create a FIFO (a named pipe) named path with the specified mode. FIFOs are named pipe which can be accessed like other regular files. This method only create FIFO but don’t open it and the created FIFO does exist until they are deleted. FIFOs are generally us as rendezvous between client and “server type processes.

os.mkfifo() Syntax in Python

Syntax: os.mkfifo(path, mode = 0o666, *, dir_fd = None)

Parameters:

• path: A path-like object representing the file system path. It can be a string or bytes object representing a file path.
• mode (optional): A numeric value representing the mode of the FIFO (named pipe) to be created. The default value of mode parameter is 0o666 (octal).
• dir_fd (optional): This is a file descriptor referring to a directory.

Note: The ‘*’ in parameter list indicates that all following parameters (Here in our case ‘dir_fd’) are keyword-only parameters and they can be provided using their name, not as a positional parameter.

Return type: This method does not return any value.

Python os.mkfifo() Method Example

Here, are various example of os.mkfifo() method. here we are explaing some generally used example of os.mkfifo() Method those are following.

Use of os.mkfifo() Method

In this example The Python code creates a named pipe (FIFO) named “./mypipe” with permissions 0o600 using `os.mkfifo()`, and then prints a success message. Named pipes facilitate inter-process communication on Unix-like systems.

Python3

# importing os module 
import os   
  
# Path 
path = "./mypipe"
  
# Mode of the FIFO (a named pipe) 
# to be created 
mode = 0o600
  
# Create a FIFO named path 
# with the specified mode 
# using os.mkfifo() method 
os.mkfifo(path, mode) 
    
print("FIFO named '% s' is created successfully." % path) 

Output

FIFO named './mypipe' is created successfully.

Interprocess Communication with os.mkfifo()

In this example os.mkfifo() method in Python is used to create a named pipe (FIFO – First In, First Out) using the given path. Named pipes are a form of interprocess communication, allowing two or more processes to communicate with each other by reading and writing to a common pipe file.

Python3

import os

def create_fifo_pipe(pipe_path):
    try:
        # Create a named pipe
        os.mkfifo(pipe_path)
        print(f"Named pipe created at {pipe_path}")
    except OSError as e:
        print(f"Error: {e}")

def main():
    # Specify the path for the named pipe
    pipe_path = "/tmp/my_fifo_pipe"

    # Create a named pipe using os.mkfifo()
    create_fifo_pipe(pipe_path)

if __name__ == "__main__":
    main()

pipes

Named pipe created at /tmp/my_fifo_pipe

FAQ: os.mkfifo() method

1. How to Create a temporary FIFO (named pipe) in Python?

To create a temporary FIFO (named pipe) in Python, use the tempfile module to generate a unique filename, then utilize os.mkfifo() to create the named pipe with the desired permissions

2. Why we are using FIFOs for input and output in Python ?

We use FIFOs (named pipes) in Python for communication between two processes. They act like a shared channel, allowing the processes to send and receive data in an organized way. This helps them work together smoothly, making sure the data is handled one after the other, preventing conflicts or timing issues.