<h2 id="introduction">Introduction</h2>
<blockquote>
Sorting is one of the fundamental techniques used in solving problems, especially in those related to writing and implementing efficient algorithms.
</blockquote>
Usually, sorting is paired with searching - meaning we first sort elements in the given collection, then search for something within it, as it is generally easier to search for something in a sorted, rather than an unsorted collection, as we can make educated guesses and impose assumptions on the data.
<blockquote>
There are many algorithms that can efficiently sort elements, but in this guide we'll be taking a look at how to implement Radix Sort in Java.
</blockquote>
<h2 id="radixsortinjava">Radix Sort in Java</h2>
Radix Sort is a non-comparative sorting algorithm, meaning it doesn't sort a collection by comparing each of the elements within it, but instead relies on something called the radix to sort the collection.
<blockquote>
The radix (often called the base) is the number of unique digits in a positional numeral system, used to represent numbers.
</blockquote>
For the well-known binary system, the radix is 2 (it uses only two digits - 0 and 1). For the arguably even more well-known decimal system, the radix is 10 (it uses ten digits to represent all numbers - from 0 to 9).
<blockquote>
How does Radix Sort use this to its advantage?
</blockquote>
Radix Sort doesn't sort by itself, really. It uses any stable, non-comparative sorting algorithm as its subroutine - and in most cases, the subroutine is Counting Sort.
<img src="https://s3.stackabuse.com/media/articles/radix-sort-in-python-1.png" alt="stable sorting">
If <code>n</code> represents the number of elements we are to sort, and <code>k</code> is the range of allowed values for those elements, Counting Sort's time complexity is <code>O(n+k)</code> when <code>k</code> is in range from <code>1...n</code>, which is significantly faster than the typical comparative sorting algorithm with a time complexity of <code>O(nlogn)</code>.
<blockquote>
But the problem here is - if the range is <code>1...n²</code>, the time complexity drastically deteriorates to <code>O(n²)</code> very quickly.
</blockquote>
The general idea of Radix Sort is to sort digit by digit from the least significant ones to the most significant (LSD Radix Sort) and you can also go the other way around (MSD Radix Sort). It allows Counting Sort to do its best by partitioning the input and running Counting Sort multiple times on sets that don't let <code>k</code> approach <code>n²</code>.
Because it's not comparison based, it's not bounded by <code>O(nlogn)</code> - it can even perform in linear time.
Since the heavy lifting is done by Counting Sort, let's first go ahead and take a look at how it works and implement it, before diving into Radix Sort itself!
<h3 id="countingsortinjavatheoryandimplementation">Counting Sort in Java - Theory and Implementation</h3>
<blockquote>
Counting Sort is a non-comparative, stable sorting algorithm, and it's main use is for sorting arrays of integers.
</blockquote>
The way it works is, it counts the number of objects having distinct key values, and then applies a prefix sum on those same counts to determine the position of each key value in the output. Being stable, the order of records with equal keys is preserved when the collection is sorted.
This operation results in, essentially, a list of integer occurrences, which we typically name the count array. Counting Sort uses the auxiliary count array to determine the positions of elements:
<img src="https://s3.stackabuse.com/media/articles/radix-sort-in-python-2.png" alt="">
Each index in the output array represents an element in the input array. The value associated with this index is the number of occurrences (the count) of the element in the input array.
The best way to show how Counting Sort works is through an example. Consider we have the following array:
<pre><code class="hljs">int[] arr = {3, 0, 1, 1, 8, 7, 5, 5};
</code></pre>
For the sake of simplicity, we'll be using digits from 0 through 9. The maximum value of a digit we can take into consideration is obviously 9, so we'll set a <code>max = 9</code>.
This is important because we need an additional, auxiliary array consisting of <code>max + 1</code> elements. This array will be used to count the number of appearances of every digit within our array <code>arr</code>, so we need to initialize the whole counting array <code>countingArray</code> to <code>0</code>.
<pre><code class="hljs">int[] countingArray = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
// there are 10 digits, so one zero for every element
</code></pre>
Now that we've both defined the array we'll be working with and initialized the counting array, we need to do the following steps to implement Counting Sort:
1. Traversing through our <code>arr</code> array, and counting the occurrence of every single element while incrementing the element on the position <code>arr[i]</code> in our <code>countingArray</code> array:
<pre><code class="hljs">for(int i = 0; i &lt; arr.length; i++)
 countingArray[arr[i]]++;
</code></pre>
After this step, <code>countingArray</code> has the following elements: <code>[1, 2, 0, 1, 0, 2, 0, 1, 1, 0]</code>.
2. The next step is applying prefix sums on the <code>countingArray</code>, and we get the following:
<pre><code class="hljs">for(int i=1; i &lt; countingArray.length; i++)
 countingArray[i] += countingArray[i-1];
</code></pre>
After the modification of the counting array it now consists of <code>countingArray = {1, 3, 3, 4, 4, 6, 6, 7, 8, 8}</code>.
3. The third and last step is to calculate element positions in the sorted output based on the values in <code>countingArray</code>. For that we'll need a new array that we'll call <code>outputArray</code>, and we'll initialize it to <code>m</code> zeros, where <code>m</code> is the number of elements in our original array <code>arr</code>:
<pre><code class="hljs">int[] outputArray = {0, 0, 0, 0, 0, 0, 0, 0};
// there are 8 elements in the arr array
</code></pre>
<blockquote>
Since Counting Sort is a stable sorting algorithm, we'll be iterating through the <code>arr</code> array in reverse order, lest we end up switching the elements.
</blockquote>
We'll find the index in our <code>countingArray</code> that is equal to the value of the current element <code>arr[i]</code>. Then, at the position <code>countingArray[arr[i]] - 1</code> we'll place the element <code>arr[i]</code>.
This guarantees the stability of this sort, as well as placing every element in it's right position in the sorted order. Afterwards, we'll decrement the value of <code>countingArray[i]</code> by 1.
At the end, we'll be copying the <code>outputArray</code> to <code>arr</code> so that the sorted elements are contained within <code>arr</code> now.
Let's unify all of these snippets and completely implement Counting Sort:
<pre><code class="hljs">int[] arr = {3, 0, 1, 1, 8, 7, 5, 5};
int[] countingArray = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

for(int i = 0; i &lt; arr.length; i++)
 countingArray[arr[i]]++;

for(int i=1; i &lt; countingArray.length; i++)
 countingArray[i] += countingArray[i-1];

int[] outputArray = {0, 0, 0, 0, 0, 0, 0, 0};
for(int i = arr.length-1; i &gt;= 0; i--){
 outputArray[countingArray[arr[i]] - 1] = arr[i];
 countingArray[arr[i]]--;
}

for(int i = 0; i &lt; arr.length; i++){
 arr[i] = outputArray[i];
 System.out.print(arr[i] + &quot; &quot;);
}
</code></pre>
Running this will give us a sorted array:
<pre><code class="hljs">0, 1, 1, 3, 5, 5, 7, 8
</code></pre>
As mentioned earlier, the time complexity of this algorithm is <code>O(n+k)</code> where <code>n</code> is the number of elements in <code>arr</code>, and <code>k</code> is the value of the <code>max</code> element in the array. However, as <code>k</code> approaches <code>n²</code> this algorithm deteriorates towards <code>O(n²)</code>, which is a major downside of the algorithm.
Since we've briefly explained how Counting Sort works, let's move on to the main topic of this article - Radix Sort.
<h3 id="radixsortinjavatheoryandimplementation">Radix Sort in Java - Theory and Implementation</h3>
Again, Radix Sort typically uses Counting Sort as a subroutine, so Radix Sort itself is a stable sorting algorithm as well.
The keys used by the Counting Sort will be the digits of the integers within the array we're sorting.
<blockquote>
There are two variants of Radix Sort - one that sorts from the Least Significant Digit (LSD), and the second one that sorts from the Most Significant Digit (MSD) - we'll be focusing on the LSD approach.
</blockquote>
Radix Sort by itself isn't very complicated to understand once we understand how Counting Sort works, so the steps taken to implement it are fairly simple:
<ol>
<li>Find the <code>max</code> element in the input array.</li>
<li>Determine the number of digits, <code>d</code>, the <code>max</code> element has. The number <code>d</code> represents how many times we'll go through the array using Counting Sort to sort it.</li>
<li>Initialize the number <code>s</code> to 1 at the beginning, representing the least significant place and working its value up by multiplying it by 10 every time.</li>
</ol>
<blockquote>
For example, let's say we have the following input array <code>arr = {73, 481, 57, 23, 332, 800, 754, 125}</code>. The number of times we'll loop through the array is 3, since the <code>max</code> element in our <code>arr</code> array is 800, which has 3 digits.
</blockquote>
Let's go through a visual example of an array being sorted this way, step by step, to see how Radix Sort sorts the elements in each iteration:
<img src="https://s3.stackabuse.com/media/articles/radix-sort-in-python-3.png" alt="">
The input array is broken down into the digits that make up its original elements. Then - either using by the most significant digit and working our way down, or the least significant digit and working our way up, the sequence is sorted via Counting Sort:
<img src="https://s3.stackabuse.com/media/articles/radix-sort-in-python-4.png" alt="">
In the first pass, only the right-hand side is used to sort, and this is why stability in Radix Sort/Counting Sort is key. If there was no stability, there would be no point in sorting this way. In the second pass, we use the middle row, and finally - the left-hand row is used, and the array is fully sorted.
Finally, let's implement Radix Sort:
<pre><code class="hljs">static void radixSort(int[] arr) {
 int max = arr[0];
 for (int i = 1; i &lt; arr.length; i++) {
 if (max &lt; arr[i])
 max = arr[i];
 }

 for (int s = 1; max / s &gt; 0; s *= 10)
 countingSortForRadix(arr, s);
}
</code></pre>
We'll also want to slightly modify Counting Sort.
This modification of Counting Sort does the exact same thing as the previous implementation, only it focuses on digits in different places of the integers at a time:
<pre><code class="hljs">static void countingSortForRadix(int[] arr, int s) {
 int[] countingArray = {0,0,0,0,0,0,0,0,0,0};
 for (int i = 0; i &lt; arr.length; i++)
 countingArray[(arr[i] / s) % 10]++;

 for (int i = 1; i &lt; 10; i++)
 countingArray[i] += countingArray[i - 1];

 int[] outputArray = {0,0,0,0,0,0,0,0};
 for (int i = arr.length - 1; i &gt;= 0; i--)
 outputArray[--countingArray[(arr[i] / s) % 10]] = arr[i];

 for (int i = 0; i &lt; arr.length; i++)
 arr[i] = outputArray[i];
}
</code></pre>
Let's create an array and try sorting it now:
<pre><code class="hljs">public static void main(String[] args) {
 int[] arr = {73,481,57,23,332,800,754,125};

 radixSort(arr);
 for (int i = 0; i &lt; arr.length; i++)
 System.out.print(arr[i] + &quot; &quot;);
}
</code></pre>
This results in:
<pre><code class="hljs">23, 57, 73, 125, 332, 481, 754, 800
</code></pre>
Since we are using Counting Sort as the main subroutine, for an array containing <code>n</code> elements, that has the <code>max</code> element with <code>d</code> digits, in a system with a <code>b</code> base, we have the time complexity of <code>O(d(n+b))</code>.
That's because we're repeating the Counting Sort process <code>d</code> times, which has <code>O(n+b)</code> complexity.
<h2 id="conclusion">Conclusion</h2>
Although Radix Sort can run very efficiently and wonderfully, it requires some specific cases to do so. Because it requires that you represent the items to be sorted as integers, it's easy to see why some other comparison-based sorting algorithms can prove to be a better choice in many cases.
The additional memory requirements of Radix Sort compared to some other comparison based algorithms is also one of the reasons that this sorting algorithm is used more rarely than not.
On the other hand, this algorithm performs superbly when the input array has shorter keys, or the range of elements is smaller.

David Landup

Branko Ilic

In this guide, you'll learn the theory behind Radix Sort and Counting Sort through visual examples, as well as implement them both in Java!

Radix Sort in Java

<h2 id="introduction">Introduction</h2>
The Portable Document Format (PDF) is not a WYSIWYG (What You See is What You Get) format. It was developed to be platform-agnostic, independent of the underlying operating system and rendering engines.
To achieve this, PDF was constructed to be interacted with via something more like a programming language, and relies on a series of instructions and operations to achieve a result. In fact, PDF is based on a scripting language - <a rel="nofollow nopener noreferrer" target="_blank" href="https://www.adobe.com/products/postscript.html">PostScript</a>, which was the first device-independent Page Description Language.
In this guide, we'll be using <a rel="nofollow noopener noreferrer" target="_blank" href="https://borbpdf.com/">borb</a> - a Python library dedicated to reading, manipulating and generating PDF documents. It offers both a low-level model (allowing you access to the exact coordinates and layout if you choose to use those) and a high-level model (where you can delegate the precise calculations of margins, positions, etc to a layout manager).
<blockquote>
In this guide, we'll take a look at how to split and merge PDF documents in Python using borb, we'll also look at how to rotate pages in a PDF document.
</blockquote>
Splitting and merging PDF documents are the basis for many use-cases:
<ul>
<li>Processing an invoice (you don't need the terms and conditions so you can remove those pages)</li>
<li>Adding a cover letter to documents (a test report, an invoice, promotional material)</li>
<li>Aggregating test-results from heterogeneous sources</li>
<li>Etc.</li>
</ul>
<h2 id="installingborb">Installing borb</h2>
borb can be downloaded from source on <a rel="nofollow noopener noreferrer" target="_blank" href="https://github.com/jorisschellekens/borb">GitHub</a>, or installed via <code>pip</code>:
<pre><code class="hljs">$ pip install borb
</code></pre>
<h2 id="splittingapdfusingborb">Splitting a PDF using borb</h2>
To demonstrate this, you'll need a PDF with a few pages. 
We'll start by creating such a PDF using <code>borb</code>. This step is optional, you can of course simply use a PDF you have laying around instead:
<pre><code class="hljs">from borb.pdf.canvas.color.color import HexColor
from borb.pdf.canvas.layout.page_layout.multi_column_layout import SingleColumnLayout
from borb.pdf.canvas.layout.page_layout.page_layout import PageLayout
from borb.pdf.canvas.layout.text.paragraph import Paragraph
from borb.pdf.document import Document
from borb.pdf.page.page import Page
from borb.pdf.pdf import PDF
from decimal import Decimal

def create_document(heading_color: HexColor = HexColor(&quot;0b3954&quot;), 
 text_color: HexColor = HexColor(&quot;de6449&quot;),
 file_name: str = &quot;output.pdf&quot;):

 d: Document = Document()

 N: int = 10
 for i in range(0, N):
 
 # Create a new Page, and append it to the Document
 p: Page = Page()
 d.append_page(p)
 
 # Set the PageLayout of the new Page
 l: PageLayout = SingleColumnLayout(p)
 
 # Add the paragraph to identify the Page
 l.add(Paragraph(&quot;Page %d of %d&quot; % (i+1, N),
 font_color=heading_color,
 font_size=Decimal(24)))
 
 # Add a Paragraph of dummy text 
 l.add(Paragraph(&quot;&quot;&quot;
 Lorem Ipsum is simply dummy text of the printing and typesetting industry. 
 Lorem Ipsum has been the industry&#x27;s standard dummy text ever since the 1500s, 
 when an unknown printer took a galley of type and scrambled it to make a type specimen book. 
 It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. 
 It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, 
 and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.
 &quot;&quot;&quot;,
 font_color=text_color))
 
 # Persist the Document to disk
 with open(file_name, &quot;wb&quot;) as pdf_out_handle:
 PDF.dumps(pdf_out_handle, d)
</code></pre>
This example code generates a PDF document consisting of 10 pages:
<ul>
<li>Each page starts with &quot;Page x of 10&quot;. This will make it easier to identify the pages later on.</li>
<li>Each page contains 1 paragraph of text.</li>
</ul>
<h2 id="splittingpdfdocumentsinpython">Splitting PDF Documents in Python</h2>
Now let's split this PDF. We'll start by splitting it in two, the first half containing the first 5 pages, and the second half containing the remaining pages:
<pre><code class="hljs">def split_half_half():

 # Read PDF
 with open(&quot;output.pdf&quot;, &quot;rb&quot;) as pdf_file_handle:
 input_pdf = PDF.loads(pdf_file_handle)

 # Create two empty PDFs to hold each half of the split
 output_pdf_001 = Document()
 output_pdf_002 = Document()

 # Split
 for i in range(0, 10):
 if i &lt; 5:
 output_pdf_001.append_page(input_pdf.get_page(i))
 else:
 output_pdf_002.append_page(input_pdf.get_page(i))

 # Write PDF
 with open(&quot;output_001.pdf&quot;, &quot;wb&quot;) as pdf_out_handle:
 PDF.dumps(pdf_out_handle, output_pdf_001)

 # Write PDF
 with open(&quot;output_002.pdf&quot;, &quot;wb&quot;) as pdf_out_handle:
 PDF.dumps(pdf_out_handle, output_pdf_002)
</code></pre>
We've extracted the first 5 pages into a new <code>Document</code>, and the following 5 pages into a second new <code>Document</code>, effectively splitting the original one into two smaller entities.
<blockquote>
This is made easy via the <code>get_page()</code> method, as its return type can be directly used to with <code>append_page()</code>.
</blockquote>
You can check the resulting PDFs to verify the code works as intended:
<img src="https://s3.stackabuse.com/media/articles/split-merge-and-rotate-pdf-documents-in-python-with-borb-2.png" alt="splitting a pdf document in python">
<img src="https://s3.stackabuse.com/media/articles/split-merge-and-rotate-pdf-documents-in-python-with-borb-3.png" alt="spllitting a pdf document in python">
<blockquote>
The first document ends at page 5, and the second one starts at page 6.
</blockquote>
We can also split it based on other criteria as well! In the next example we'll split the PDF by putting all odd pages in one PDF, and the even pages in another one:
<pre><code class="hljs">def split_even_odd():

 # Read PDF
 with open(&quot;output.pdf&quot;, &quot;rb&quot;) as pdf_file_handle:
 input_pdf = PDF.loads(pdf_file_handle)
 
 # Rreate two empty PDFs to hold each half of the split
 output_pdf_001 = Document()
 output_pdf_002 = Document()

 # Split
 for i in range(0, 10):
 if i % 2 == 0:
 output_pdf_001.append_page(input_pdf.get_page(i))
 else:
 output_pdf_002.append_page(input_pdf.get_page(i))

 # Write PDF
 with open(&quot;output_001.pdf&quot;, &quot;wb&quot;) as pdf_out_handle:
 PDF.dumps(pdf_out_handle, output_pdf_001)

 # Write PDF
 with open(&quot;output_002.pdf&quot;, &quot;wb&quot;) as pdf_out_handle:
 PDF.dumps(pdf_out_handle, output_pdf_002)
</code></pre>
You can verify the resulting PDF documents represent the aforementioned split:
<img src="https://s3.stackabuse.com/media/articles/split-merge-and-rotate-pdf-documents-in-python-with-borb-4.png" alt="split pdf on odd pages">
<img src="https://s3.stackabuse.com/media/articles/split-merge-and-rotate-pdf-documents-in-python-with-borb-5.png" alt="split pdf on odd pages">
<h2 id="mergingpdfdocumentsinpython">Merging PDF Documents in Python</h2>
In order to work the next examples we'll need two PDF's. Let's use the earlier code to generate them if you don't already have some:
<pre><code class="hljs">create_document(HexColor(&quot;247B7B&quot;), HexColor(&quot;78CDD7&quot;), &quot;output_001.pdf&quot;)
create_document(file_name=&quot;output_002.pdf&quot;)
</code></pre>
The intuition used for splitting is pretty similar to merging - though, we can add entire documents to other documents, not just pages. Though, sometimes you might want to split a document (cut off the last page) before merging it with another one.
We can merge them entirely (concatenating both PDFs), but we can also just add some pages of the first PDF to the second if we'd prefer it that way - using the <code>append_page()</code> function like before.
Let's start by concatenating them entirely:
<pre><code class="hljs">def concatenate_two_documents():

 # Read first PDF
 with open(&quot;output_001.pdf&quot;, &quot;rb&quot;) as pdf_file_handle:
 input_pdf_001 = PDF.loads(pdf_file_handle)
 
 # Read second PDF
 with open(&quot;output_002.pdf&quot;, &quot;rb&quot;) as pdf_file_handle:
 input_pdf_002 = PDF.loads(pdf_file_handle)
 
 # Build new PDF by concatenating two inputs
 output_document = Document()
 output_document.append_document(input_pdf_001)
 output_document.append_document(input_pdf_002)
 
 # Write PDF
 with open(&quot;output.pdf&quot;, &quot;wb&quot;) as pdf_out_handle:
 PDF.dumps(pdf_out_handle, output_document)
</code></pre>
This code should result in:
<img src="https://s3.stackabuse.com/media/articles/split-merge-and-rotate-pdf-documents-in-python-with-borb-6.png" alt="merging pdf documents in python with borb">
<h2 id="rotatingpagesinpdfdocumentsinpython">Rotating Pages in PDF Documents in Python</h2>
A page in a PDF document can be rotated by any multiple of 90 degrees. This kind of operation allows you to easily switch between landscape and portrait mode.
In the next example you'll rotate a page from one of the input PDFs we created earlier:
<pre><code class="hljs">def rotate_first_page():
 # Read PDF
 with open(&quot;output_001.pdf&quot;, &quot;rb&quot;) as pdf_file_handle:
 input_pdf_001 = PDF.loads(pdf_file_handle)

 # Rotate page
 input_pdf_001.get_page(0).rotate_left() 
 
 # Write PDF to disk
 with open(&quot;output.pdf&quot;, &quot;wb&quot;) as pdf_out_handle:
 PDF.dumps(pdf_out_handle, input_pdf_001)
</code></pre>
The resulting PDF looks like this:
<img src="https://s3.stackabuse.com/media/articles/split-merge-and-rotate-pdf-documents-in-python-with-borb-7.png" alt="rotating pages of pdf documents in python">
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to merge and split PDF documents. We've also modified an existing PDF by rotating some of its pages.

Joris Schellekens

In this guide, we'll use borb, a pure-Python PDF library to split, merge and rotate pages of PDF documents in Python, with practical examples!

Split, Merge and Rotate PDF Documents in Python with borb

In this in-depth practical tutorial, learn everything you need to know about the @Query annotation with Spring Data MongoDB and Spring Boot!

Spring Data MongoDB - Guide to the @Query Annotation

Lazar Ristic

In this beginner-oriented guide, we'll take a look at JavaScript's built-in array functions, how to work with arrays and some tips and tricks.

Working with JavaScript's Built-In Array Functions

In this guide, we'll take a look at JavaScript's built-in string functions, and how to utilize them, as well as some tips and tricks on good practices.

Working with JavaScript's Built-In String Functions

Hiram Kamau

In this detailed and extensive guide to the filter() method in Java 8 - you'll understand how the method works, as well as several use-cases and how to get the best performance out of large datasets.

Java 8 Streams: Definitive Guide to the filter() Method

<h2 id="introduction">Introduction</h2>
Design patterns help make code understandable, scalable, and reusable. There are different categories of design patterns, depending on the problems being addressed. When code is modularized, it's easier to add newer features without making drastic changes to the project.
The Abstract Factory Design Pattern is a creational pattern that provides a framework to create interfaces of closely related objects without specifying their classes - hence the term &quot;abstract&quot;.
An abstract class is partially implemented and defines the requirements that its child classes should have and some generic child behavior as well as what functions they should have. Concrete classes extend abstract classes and provide the unimplemented functionality, while inheriting the common functionalities.
<h3 id="abstractclassesinpython">Abstract Classes in Python</h3>
<blockquote>
For instance, all <code>Animal</code>s have an <code>eat()</code> function, commonly implemented between all animals, but each have unique <code>speak()</code> functions so the abstract <code>Animal</code> class leaves that up to the children.
</blockquote>
In Python, every abstract class is derived from the <code>ABC</code> class of the <code>abc</code> module. The abstract method is declared inside the abstract class but not implemented, and all implemented methods are passed down to concrete classes.
In the following example, notice that the <code>AbstractClass</code> definition contains an <code>@abstractmethod</code> decorator. By decorating a function with it, we define that all child classes must have an implementation of the <code>func()</code> method, as there is no default, common implementation:
<pre><code class="hljs">from abc import ABC, abstractmethod

class AbstractClass(ABC):
 @abstractmethod
 def func():
 pass
</code></pre>
The partial implementation of the parent abstract factory class is fulfilled by its children/concrete class. Each child class will contain a <code>func()</code> method to fulfill the abstract class' requirements.
Building from our previous example, we can create a child class like this:
<pre><code class="hljs">from abc import ABC, abstractmethod

class AbstractClass(ABC):
 @abstractmethod
 def func(self):
 pass

class ChildClass(AbstractClass):
 def func(self):
 out = &quot;This is an output&quot;
 return out

obj = ChildClass()
print(obj.func())
</code></pre>
<h2 id="abstractfactorydesignpatterninpython">Abstract Factory Design Pattern in Python</h2>
Coming back to the definition of the Abstract Factory Pattern:
<blockquote>
Through the Abstract Factory Pattern, we define interfaces to create families of related objects without specifying their concrete classes.
</blockquote>
Therefore, the Abstract Factory Pattern delegates the creation of objects to another class. This pattern is best suited when one wishes to create multiple categories of an object by abstracting its implementation.
You may be familiar with the concept factories - these are objects that create other objects. The Abstract Factory Pattern is primarily concerned with the interface for factory objects.
What's a family of objects?
<blockquote>
A table can be round, square or oval. In a similar sense, a common class such as an <code>Employee</code> might branch out to several more concrete classes.
</blockquote>
Here's a visual representation of the Abstract Factory Pattern:
<img src="https://stackabuse.s3.amazonaws.com/media/abstract-factory-design-pattern-in-python-01.jpeg" alt="Visual Representation of the Abstract Factory Pattern in Python">
Assume that you are designing a family of two products (a browser and a messenger).
<ul>
<li>
Abstract Products: Two abstract classes are created, one for the browser and another for the messenger. These classes contain abstract methods that are mandatory for the construction of the products. These abstract classes are referred to as interfaces.
In the example shown above, the Web Browser and Messenger are the abstract products.
</li>
<li>
Concrete Products: Concrete products inherit the abstract methods from the abstract classes i.e. abstract products. Using the interfaces, different families of products can be created.
For example, in the diagram above, three different kinds of web browsers are created for three different sets of users. If there's one thing that all these concrete products have in common, that would be the abstract methods that were defined in the abstract class.
</li>
<li>
Concrete Factories: Concrete Factories create Concrete Products as directed by the Abstract Factories. The concrete factories are only capable of creating those products that are specified in them - a <code>BrowserFactory</code> creates browsers, while a <code>MessengerFactory</code> creates messengers. Alternatively, you can focus on some common features, and say - create a <code>BasicFactory</code> and <code>SecureFactory</code> which create basic or secure web browsers and messenger instances.
In the diagram mentioned above, the Vanilla Products Factory is capable of creating both vanilla concrete products (browser and messenger), while the Secure Products Factory makes safe versions.
</li>
<li>
Abstract Factories: The Abstract factories possess interfaces to create the abstract products i.e. they contain several methods that return abstract products.
In the example, the interfaces of concrete factories are invoked to get the abstract products as a web browser and messenger.
</li>
</ul>
<h2 id="implementation">Implementation</h2>
Acquainted with the terminology, let's try implementing the Abstract Factory Pattern in Python.
First off, we create the abstract products - <code>Browser</code> and <code>Messenger</code> as:
<pre><code class="hljs">from abc import ABC, abstractmethod

class Browser(ABC):
 &quot;&quot;&quot;
 Creates &quot;Abstract Product A&quot;
 &quot;&quot;&quot;

 # Interface - Create Search Toolbar
 @abstractmethod
 def create_search_toolbar(self):
 pass

 # Interface - Create Browser Window
 @abstractmethod
 def create_browser_window(self):
 pass

class Messenger(ABC):
 &quot;&quot;&quot;
 Creates &quot;Abstract Product B&quot;
 &quot;&quot;&quot;

 @abstractmethod
 # Interface - Create Messenger Window
 def create_messenger_window(self):
 pass
</code></pre>
These act as base classes to the following concrete classes i.e. product variants of the abstract products - vanilla and secure:
<pre><code class="hljs">class VanillaBrowser(Browser):
 &quot;&quot;&quot;
 Type: Concrete Product
 Abstract methods of the Browser base class are implemented.
 &quot;&quot;&quot;

 # Interface - Create Search Toolbar
 def create_search_toolbar(self):
 print(&quot;Search Toolbar Created&quot;)

 # Interface - Create Browser Window]
 def create_browser_window(self):
 print(&quot;Browser Window Created&quot;)


class VanillaMessenger(Messenger):
 &quot;&quot;&quot;
 Type: Concrete Product
 Abstract methods of the Messenger base class are implemented.
 &quot;&quot;&quot;

 # Interface - Create Messenger Window
 def create_messenger_window(self):
 print(&quot;Messenger Window Created&quot;)

class SecureBrowser(Browser):
 &quot;&quot;&quot;
 Type: Concrete Product
 Abstract methods of the Browser base class are implemented.
 &quot;&quot;&quot;

 # Abstract Method of the Browser base class
 def create_search_toolbar(self):
 print(&quot;Secure Browser - Search Toolbar Created&quot;)

 # Abstract Method of the Browser base class
 def create_browser_window(self):
 print(&quot;Secure Browser - Browser Window Created&quot;)

 def create_incognito_mode(self):
 print(&quot;Secure Browser - Incognito Mode Created&quot;)


class SecureMessenger(Messenger):
 &quot;&quot;&quot;
 Type: Concrete Product
 Abstract methods of the Messenger base class are implemented.
 &quot;&quot;&quot;

 # Abstract Method of the Messenger base class
 def create_messenger_window(self):
 print(&quot;Secure Messenger - Messenger Window Created&quot;)

 def create_privacy_filter(self):
 print(&quot;Secure Messenger - Privacy Filter Created&quot;)

 def disappearing_messages(self):
 print(&quot;Secure Messenger - Disappearing Messages Feature Enabled&quot;)
</code></pre>
You can notice that apart from the abstract methods, there are also extra features added to the concrete products to make them functional in their own context.
We are almost there. Let's now create the abstract factory itself and the corresponding concrete factories as:
<pre><code class="hljs">class AbstractFactory(ABC):
 &quot;&quot;&quot;
 The Abstract Factory
 &quot;&quot;&quot;

 @abstractmethod
 def create_browser(self):
 pass

 @abstractmethod
 def create_messenger(self):
 pass

class VanillaProductsFactory(AbstractFactory):
 &quot;&quot;&quot;
 Type: Concrete Factory
 Implement the operations to create concrete product objects.
 &quot;&quot;&quot;

 def create_browser(self):
 return VanillaBrowser()

 def create_messenger(self):
 return VanillaMessenger()

class SecureProductsFactory(AbstractFactory):
 &quot;&quot;&quot;
 Type: Concrete Factory
 Implement the operations to create concrete product objects.
 &quot;&quot;&quot;

 def create_browser(self):
 return SecureBrowser()

 def create_messenger(self):
 return SecureMessenger()
</code></pre>
In the code above, since the <code>AbstractFactory</code> acts as a base class, the abstract methods are instantiated just as mentioned in the base class.
Let's add a <code>main()</code> method so we an see our example in action:
<pre><code class="hljs">def main():
 for factory in (VanillaProductsFactory(), SecureProductsFactory()):
 product_a = factory.create_browser()
 product_b = factory.create_messenger()
 product_a.create_browser_window()
 product_a.create_search_toolbar()
 product_b.create_messenger_window()

if __name__ == &quot;__main__&quot;:
 main()
</code></pre>
If you'd like to see the entire code file, you can find it in the repo <a href="https://github.com/StackAbuse/abstract-factory-design-pattern-in-python" target="_blank" rel="noopener nofollow noreferrer">on GitHub</a>.
If we execute our code, it returns the following output showing the creation of the secure browser and the secure messenger:
<pre><code class="hljs">$ python3 abstract_factory_code.py
Browser Window Created
Search Toolbar Created
Messenger Window Created
Secure Browser - Browser Window Created
Secure Browser - Search Toolbar Created
Secure Messenger - Messenger Window Created
</code></pre>
<h2 id="proscons">Pros &amp; Cons</h2>
Now that we have implemented the pattern, let's weigh their pros and cons.
Pros:
<ul>
<li>
The main advantage of this pattern is flexibility - the ability to add newer features and functions to the existing products or perhaps even add newer concrete products to the concrete factories. This can be done without sabotaging the whole code.
</li>
<li>
There is minimal direct interaction between the client and the concrete products. There is also flexibility in organizing and compacting the code.
</li>
</ul>
Cons
<ul>
<li>The major drawback of this pattern is the readability and maintainability of the code. Although it provides a flexible way to add new futures, adding a new component will require adding to the concrete classes, modifying the interfaces, etc. The cascading effects of modification take development time.</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
The Abstract Factory Pattern can be used very effectively for closely related families of different products unlike the Factory Pattern, which can be used only for a single type of product.
<blockquote>
If you are interested in learning more about it, read our guide to the <a href="https://stackabuse.com/the-factory-method-design-pattern-in-python/" target="_blank">Factory Pattern in Python</a>.
</blockquote>
The Abstract Factory Pattern solves a major crisis for the need to write clean code. We have covered the basics of this pattern and also understood the implementation using an example.

Marcus Sanatan

Sathiya Sarathi Gunasekaran

The Abstract Factory Design Pattern is a creational pattern that provides a framework to create interfaces of closely related objects without specifying their classes.

Abstract Factory Design Pattern in Python

Naazneen Jatu

In this guide, we will create a REST API in Python with Django, using the Django REST Framework to create a shopping cart application.