How to create and use a named pipe in Python?

Consider a pipeline that allows for seamless data flow and communication between various components of a complex system. Named pipes are similar conduits in Python programming, making it easier for programs to communicate with each other and other processes. Named pipes, which are also referred to as FIFOs (First-In, First-Out), are a powerful way to exchange data between processes on the same system or even between systems. In this article, we will take a journey into Python to learn how to create and use named pipes. We'll unwind the step by step process of making a named pipe, writing and reading data through it, and even exhibit advanced scenarios. Therefore, let's explore the world of named pipes and discover their potential!

Grasping what Named Pipes are

Named pipes are special files that exist in the Python file system and act like conventional pipes. In contrast to anonymous pipes, which are restricted to communication between parent and child processes, named pipes, transcend process boundaries. Therefore, a named pipe can be used to communicate between processes that are unrelated to one another, making it an invaluable tool.

A named pipe is like a file but it doesn't store anything. It just has a path. It can be opened, read from, and written to, but the content is temporarily stored in the system memory. It acts a bit differently than a normal file. When it is opened it can be opened as read-only or write-only not both read-write. The idea is you would have one process with it open for writing (the server) and another process with it open for reading (the client).

How to Make a Named Pipe?

To make a named pipe in Python, we use the os module. Let's import it first:

import os

Then, we declare the path and name for our named pipe:

pipe_path = "/path/to/named_pipe"

We make use of the os module's mkfifo() function to create the named pipe:


A named pipe at the specified path has been successfully created using this code. It is important to note that the named pipe should only be accessed by processes that have the proper permissions.


Making Use of a Known Pipe to Write

Let's find a way how to insert data into our named pipe as we have built it anyhow. In this example, we'll make use of the open() function so that the named pipe is opened in write mode and data is written to it:


By opening the named pipe in write mode, we can also make use of the compose() method to send data through it. In this instance, we see that the string "Hello, named pipe!" is written.

with open(pipe_path, "w") as pipe:
   pipe.write("Hello, named pipe!")

Reading from a Named Line

So as to read data from the named pipe, we open the named pipe in read mode and deploy the read() or readline() methods.


In this particular example, we make use of the read() method to fetch the data after opening the named pipe in read mode. The data are then printed to the console.

with open(pipe_path, "r") as pipe:

   data =

Cleaning up the Named Pipe

After we are done working on the named pipe, we need to tidy it up and get rid of it from the file system. This can be achieved with the help of the os.remove() function:


For example, we remove the named pipe from the file system by calling os.remove() function and provide the path to it. This ensures a neat exit and prevents resource leaks.


To begin, we import the os and posix modules and specify the named pipe's path and name. After that, we implement a try-except block to handle any possible exceptions that may arise during the process of creating the named pipe. The posix.mkfifo() function is used to create the named pipe at the specified path within the try block. We display a message indicating the successful generation of the named pipe. On the off chance that the named pipe as of now exists, we notify the user. Assuming some other error happens, we catch the error and display a proper error message.

import os
import posix

pipe_path = "/content/named_pipe"

   print("Named pipe created successfully!")
except FileExistsError:
   print("Named pipe already exists!")
except OSError as e:
   print(f"Named pipe creation failed: {e}")

In this particular case, the output is

Named pipe already exists!


In this example, we import the os module and declare the named pipe's path and name. We then deploy a try-except block to deal with likely exception cases during the reading of data from the named pipe. We use the read() method to read the data after opening the named pipe in read mode within the try block using open() method. We display the data to the console after storing it in the data variable. If there is no such thing as the named pipe, we catch the FileNotFoundError and notify the user. We catch additional errors if any and display the corresponding error messages.

import os

# Specify the path and name of the named pipe
pipe_path = "/path/to/named_pipe"

# Read data from the named pipe
   with open(pipe_path, "r") as pipe:
      data =
   print(f"Read data from named pipe: {data}")
except FileNotFoundError:
   print("Named pipe does not exist!")
except OSError as e:
   print(f"Failed to read data from named pipe: {e}")


In one particular case, the output can be

Named pipe does not exist!

You have learned how to create, write to, and read data from a named pipe in this interesting Python article on Named pipes. Named pipes act as strong go-betweens or agents for communication between processes, and permitting disparate processes to flawlessly exchange data. You now have a comprehensive understanding of how to create and use named pipes in Python thanks to the code examples provided.

You now have a versatile tool for building complex systems, coordinating processes, and unlocking new possibilities in your Python projects with the ability to create and use named pipes. In this way, go forward and explore different possibilities regarding named pipes, involving proficient communication between your Python programs.

Updated on: 17-Jul-2023

5K+ Views

Kickstart Your Career

Get certified by completing the course

Get Started