<h2 id="introduction">Introduction</h2>
Sorting refers to arranging items of a list in a specific order (numerical or alphabetical). Sorting is generally used in tandem with searching.
It is generally easier to search for an element (called the key) in a given list if the list is sorted, both visually and algorithmically.
There are many ways (algorithms) to sort a given list of elements. Merge Sort is one of the more popular, and more efficient ways to do so.
In this article, we will see the logic behind Merge Sort, implement it in JavaScript, and visualize it in action. Finally, we will compare Merge Sort with other algorithms in terms of space and time complexity.
<h2 id="understandingthelogicbehindmergesort">Understanding the Logic Behind Merge Sort</h2>
Merge sort uses the concept of divide-and-conquer to sort the given list of elements. It breaks down the problem into smaller subproblems until they become simple enough to solve directly.
Here are the steps Merge Sort takes:
<ol>
<li>Split the given list into two halves (roughly equal halves in case of a list with an odd number of elements).</li>
<li>Continue dividing the subarrays in the same manner until you are left with only single element arrays.</li>
<li>Starting with the single element arrays, merge the subarrays so that each merged subarray is sorted.</li>
<li>Repeat step 3 until you end up with a single sorted array.</li>
</ol>
Let's take a look at how Merge Sort works on an array such as <code>[4, 8, 7, 2, 11, 1, 3]</code>:
<img src="https://stackabuse.s3.amazonaws.com/media/merge-sort-in-python-1.png" alt="Merge Sort example">
<h2 id="implementationofmergesortinjavascript">Implementation of Merge Sort in JavaScript</h2>
Let us first write code to <code>merge()</code> two sorted subarrays into a sorted array. It is very important to keep in mind that both the subarrays are already sorted, and we are just combining them using the <code>merge()</code> function.
We can do this by going over both of these subarrays, and adding one by one element so that the resulting array is also sorted:
<pre><code class="hljs">function merge(left, right) {
 let arr = []
 // Break out of loop if any one of the array becomes empty
 while (left.length &amp;&amp; right.length) {
 // Pick the smaller among the smallest element of left and right sub arrays 
 if (left[0] &lt; right[0]) {
 arr.push(left.shift()) 
 } else {
 arr.push(right.shift()) 
 }
 }
 
 // Concatenating the leftover elements
 // (in case we didn&#x27;t go through the entire left or right array)
 return [ ...arr, ...left, ...right ]
}
</code></pre>
In this function, we take two sorted subarrays (<code>left</code>, <code>right</code>) and merge them to get a single sorted array. First, we create an empty array. Later, we pick the smaller of the smallest unpicked element in the <code>left</code> and <code>right</code> subarrays and push them into the empty array. We need to only check the first elements in the <code>left</code> and <code>right</code> subarrays since they are both sorted.
While doing this, we delete the picked element from the subarray (this is achieved using the <code>shift()</code> function). We continue this process until one of the subarrays becomes empty. After that, we push the leftover elements of the non-empty subarray (because they are already sorted) into the main array.
As we now have the code to merge two sorted arrays (conquer part of divide-and-conquer), let us write the final code for our Merge Sort algorithm. This means that we need to keep splitting arrays, until we end up with arrays that only contain one element:
<pre><code class="hljs">function mergeSort(array) {
 const half = array.length / 2
 
 // Base case or terminating case
 if(array.length &lt; 2){
 return array 
 }
 
 const left = array.splice(0, half)
 return merge(mergeSort(left),mergeSort(array))
}
</code></pre>
Here, we identify the midpoint and split the array into two subarrays using the <code>splice()</code> function. If there are an odd number of elements, the left one gets a smaller number of elements. We are dividing until we are left with single element arrays (<code>array.length &lt; 2</code>). After that, we start combining the subarrays using the previously written <code>merge()</code> function.
Now that we have the code in place, let's see the output of running the function on our previous example:
<pre><code class="hljs">array = [4, 8, 7, 2, 11, 1, 3];
console.log(mergeSort(array));
</code></pre>
Which gives us the expected output:
<pre><code class="hljs">1,2,3,4,7,8,11
</code></pre>
<h2 id="theefficiencyofmergesort">The Efficiency of Merge Sort</h2>
The worst-case time complexity of Merge Sort is O(nlogn), same as that for best case time complexity for <a target="_blank" href="/quicksort-in-javascript/">QuickSort</a>. When it comes to speed, Merge Sort is one of the fastest sorting algorithms out there.
Unlike Quick Sort, Merge Sort is not an in-place sorting algorithm, meaning it takes extra space other than the input array. This is because we are using auxiliary (helper) arrays to store the sub-arrays. The space complexity of the merge sort is O(n).
Another advantage of Merge Sort is that it lends itself very well to multi-threading, since each respective half can be sorted on its own. Another common way of reducing the runtime of Merge Sort is to stop when we get to relatively small subarrays (~7) and using <a target="_blank" href="/insertion-sort-in-javascript/">Insertion Sort</a> to sort them.
This is done because Insertion Sort performs really well on small, or nearly sorted arrays. Much better than its more globally efficient counterparts.
<h2 id="conclusion">Conclusion</h2>
In this article, we have seen the logic behind the Merge Sort algorithm, how to implement it in JavaScript, and learned about its performance. It's one of the basic sorting algorithms and is really useful for giving a clear example of the divide-and-conquer strategy.

Abhilash Kakumanu

In this article we'll take a look at one of the most popular sorting algorithms - Merge Sort. We'll also explain the implementation, and take a look at the efficiency.

Merge Sort in JavaScript

<h2 id="introduction">Introduction</h2>
Matplotlib is one of the most widely used data visualization libraries in Python. Matplotlib plots and visualizations are commonly shared with others, be it through papers or online.
In this article, we'll take a look at how to save a plot/graph as an image file using Matplotlib.
<h2 id="creatingaplot">Creating a Plot</h2>
Let's first create a simple plot:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)
plt.show()
</code></pre>
Here, we've plotted a sine function, starting at <code>0</code> and ending at <code>10</code> with a step of <code>0.1</code>. Running this code yields:
<img src="https://stackabuse.s3.amazonaws.com/media/change-figure-size-in-matplotlib-1.png" alt="sine visualization python">
Now, let's take a look at how we can save this figure as an image.
<h2 id="saveplotasimageinmatplotlib">Save Plot as Image in Matplotlib</h2>
In the previous example, we've generated the plot via the <code>plot()</code> function, passing in the data we'd like to visualize.
This plot is generated, but isn't shown to us, unless we call the <code>show()</code> function. The <code>show()</code> function, as the name suggests, shows the generated plot to the user in a window.
Once generated, we can also save this figure/plot as a file - using the <code>savefig()</code> function:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)
plt.savefig(&#x27;saved_figure.png&#x27;)
</code></pre>
Now, when we run the code, instead of a window popping up with the plot, we've got a file (<code>saved_figure.png</code>) in our project's directory.
This file contains the exact same image we'd be shown in the window:
<img src="https://stackabuse.s3.amazonaws.com/media/save-plot-as-image-with-matplotlib-1.png" alt="save plot in matplotlib">
It's worth noting that the <code>savefig()</code> function isn't unique to the <code>plt</code> instance. You can also use it on a <code>Figure</code> object:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

fig = plt.figure()

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)
fig.savefig(&#x27;saved_figure.png&#x27;)
</code></pre>
The <code>savefig()</code> function has a mandatory <code>filename</code> argument. Here, we've specified the filename and format.
Additionally, it accepts other options, such as <code>dpi</code>, <code>transparent</code>, <code>bbox_inches</code>, <code>quality</code>, etc.
We'll go over some popular options in the proceeding sections.
<h3 id="settingimagedpi">Setting Image DPI</h3>
The DPI parameter defines the number of dots (pixels) per inch. This is essentially the resolution of the image we're producing. Let's test out a couple of different options:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

fig = plt.figure()

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)
fig.savefig(&#x27;saved_figure-50pi.png&#x27;, dpi = 50)
fig.savefig(&#x27;saved_figure-100dpi.png&#x27;, dpi = 100)
fig.savefig(&#x27;saved_figure-1000dpi.png&#x27;, dpi = 1000)
</code></pre>
This results in three new image files on our local machine, each with a different DPI:
<img src="https://stackabuse.s3.amazonaws.com/media/save-plot-as-image-with-matplotlib-2.png" alt="save plot in matplotlib with dpi">
The default value is <code>100</code>.
<h3 id="savetransparentimagewithmatplotlib">Save Transparent Image with Matplotlib</h3>
The <code>transparent</code> argument can be used to create a plot with a transparent background. This is useful if you'll use the plot image in a presentation, on a paper or would like to present it in a custom design setting:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)
plt.savefig(&#x27;saved_figure.png&#x27;, transparent=True)
</code></pre>
If we put this image on a dark background, it'll result in:
<img src="https://stackabuse.s3.amazonaws.com/media/save-plot-as-image-with-matplotlib-3-1.png" alt="save transparent plot in matplotlib">
<h3 id="changingplotcolors">Changing Plot Colors</h3>
You can change the face color by using the <code>facecolor</code> argument. It accepts a <code>color</code> and defaults to <code>white</code>.
Let's change it to <code>red</code>:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)
plt.savefig(&#x27;saved_figure-colored.png&#x27;, facecolor = &#x27;red&#x27;)
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/save-plot-as-image-with-matplotlib-4.png" alt="change color of saved plot matplotlib">
<h3 id="settingimageborderbox">Setting Image Border Box</h3>
The <code>bbox_inches</code> argument accepts a string and specifies the border around the box we're plotting. If we'd like to set it to be <code>tight</code>, i.e. to crop around the box as much as possible, we can set the <code>bbox_inches</code> argument to <code>'tight'</code>:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)
plt.savefig(&#x27;saved_figure-tight.png&#x27;, bbox_inches = &#x27;tight&#x27;, facecolor=&#x27;red&#x27;)
</code></pre>
This results in a tightly packed box. This is easier to visualize if we color the face with a different color for reference:
<img src="https://stackabuse.s3.amazonaws.com/media/save-plot-as-image-with-matplotlib-5.png" alt="set image border box with matplotlib">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to save the plot as an image file using Matplotlib.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Limited time discount: 2-for-1, save 50%!
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with these libraries - from simple plots to animated 3D plots with interactive buttons.
<blockquote>
It serves as an in-depth guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
</blockquote>
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, covers core plotting libraries like Matplotlib and Seaborn, and shows you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.
</blockquote>

David Landup

In this tutorial, we'll go over examples of how to save a plot as an image using Matplotlib. We'll also customize it by changing the color, DPI, setting transparency, etc.

Save Plot as Image with Matplotlib

<h2 id="introduction">Introduction</h2>
Sorting refers to arranging items of a list in a specific order (numerical or alphabetical). Sorting is generally used in tandem with searching.
Over the years, many sorting algorithms have been developed, and one of the fastest ones to date is Quicksort.
Quicksort uses the divide-and-conquer strategy to sort the given list of elements. This means that the algorithm breaks down the problem into subproblems until they become simple enough to solve directly.
Algorithmically this can be implemented either recursively or iteratively. However, the recursive approach is more natural for this problem.
<h2 id="understandingthelogicbehindquicksort">Understanding the Logic Behind Quicksort</h2>
Let's take a look at how Quicksort works:
<ol>
<li>Select an element of the array. This element is generally called the pivot. Most often this element is either the first or the last element in the array.</li>
<li>Then, rearrange the elements of the array so that all the elements to the left of the pivot are smaller than the pivot and all the elements to the right are greater than the pivot. The step is called partitioning. If an element is equal to the pivot, it doesn't matter on which side it goes.</li>
<li>Repeat this process individually for the left and right side of the pivot, until the array is sorted.</li>
</ol>
Let's understand these steps further by walking through an example. Consider an array of unsorted elements <code>[7, -2, 4, 1, 6, 5, 0, -4, 2]</code>. We'll choose the last element to be the pivot. The step-by-step breakdown of the array would be as shown in the image below:
<img src="https://stackabuse.s3.amazonaws.com/media/quicksort-in-javascript-1.jpg" alt="Quick Sort Example">
Elements that have been chosen as a pivot in one step of the algorithm have a colored outline. After partitioning, pivot elements are always in their correct positions in the array.
Arrays that have a bolded black outline represent the end of that specific recursive branch since we ended up with an array that contained only one element.
We can see the resulting sorting of this algorithm by simply going through the lowest element in each &quot;column&quot;.
<h2 id="implementationofquicksortinjavascript">Implementation of Quicksort in JavaScript</h2>
As we could see, the backbone of this algorithm is the partitioning step. This step is the same regardless of whether we use the recursive or iterative approach.
With that in mind, let's first write the code to <code>partition()</code> an array:
<pre><code class="hljs">function partition(arr, start, end){
 // Taking the last element as the pivot
 const pivotValue = arr[end];
 let pivotIndex = start; 
 for (let i = start; i &lt; end; i++) {
 if (arr[i] &lt; pivotValue) {
 // Swapping elements
 [arr[i], arr[pivotIndex]] = [arr[pivotIndex], arr[i]];
 // Moving to next element
 pivotIndex++;
 }
 }
 
 // Putting the pivot value in the middle
 [arr[pivotIndex], arr[end]] = [arr[end], arr[pivotIndex]] 
 return pivotIndex;
};
</code></pre>
Here, we are taking the last element as the pivot. We are using a variable <code>pivotIndex</code> to keep track of the &quot;middle&quot; position where all the elements to the left are less, and all the elements to the right are more than the <code>pivotValue</code>.
As the last step, we swap the pivot, which is the last element in our case, with the <code>pivotIndex</code>. So, in the end, our pivot element would end up in the &quot;middle.&quot; With all elements less than the pivot to the left side of it, and all elements greater than or equal to the pivot to the right of the pivot.
<h3 id="recursiveimplementation">Recursive Implementation</h3>
Now that we have the <code>partition()</code> function, we have to recursively break this problem down and apply the partitioning logic in order to do the remaining steps:
<pre><code class="hljs">function quickSortRecursive(arr, start, end) {
 // Base case or terminating case
 if (start &gt;= end) {
 return;
 }
 
 // Returns pivotIndex
 let index = partition(arr, start, end);
 
 // Recursively apply the same logic to the left and right subarrays
 quickSort(arr, start, index - 1);
 quickSort(arr, index + 1, end);
}
</code></pre>
In this function, we start by partitioning the array. After that, we partition both left and right subarrays. We repeat that process as long as the method receives an array that isn't empty or has more than one element.
This is because empty arrays, and arrays with only one element, are considered sorted.
Let's test this code out on our original example by calling:
<pre><code class="hljs">array = [7, -2, 4, 1, 6, 5, 0, -4, 2]
quickSortRecursive(array, 0, array.length - 1)

console.log(array)
</code></pre>
This would give us the output:
<pre><code class="hljs">-4,-2,0,1,2,4,5,6,7
</code></pre>
<h3 id="iterativeimplementation">Iterative Implementation</h3>
As we mentioned previously, the recursive approach to Quicksort is much more intuitive. However, implementing Quicksort iteratively is a relatively common interview question for Software Engineers.
As with most recursive-to-iterative conversions, the first thing that should come to mind is using a stack to simulate recursive calls. This is done so we can reuse some of the recursive logic that we're familiar with, and use it in an iterative setting.
We need to somehow keep track of what unsorted subarrays we have left. One way to do this is to simply keep &quot;pairs&quot; of elements in a stack, representing the <code>start</code> and <code>end</code> of a given unsorted subarray.
JavaScript doesn't have an explicit stack data structure, but arrays support the <code>push()</code> and <code>pop()</code> functions. They don't support the <code>peek()</code> function however, so we will have to manually check the top of the stack using <code>stack[stack.length - 1]</code>.
We'll be using the same <code>partition</code> function as we did for the recursive approach. Let's see how to write the Quicksort part:
<pre><code class="hljs">function quickSortIterative(arr) {
 // Creating an array that we&#x27;ll use as a stack, using the push() and pop() functions
 stack = [];
 
 // Adding the entire initial array as an &quot;unsorted subarray&quot;
 stack.push(0);
 stack.push(arr.length - 1);
 
 // There isn&#x27;t an explicit peek() function
 // The loop repeats as long as we have unsorted subarrays
 while(stack[stack.length - 1] &gt;= 0){
 
 // Extracting the top unsorted subarray
 end = stack.pop();
 start = stack.pop();
 
 pivotIndex = partition(arr, start, end);
 
 // If there are unsorted elements to the &quot;left&quot; of the pivot,
 // we add that subarray to the stack so we can sort it later
 if (pivotIndex - 1 &gt; start){
 stack.push(start);
 stack.push(pivotIndex - 1);
 }
 
 // If there are unsorted elements to the &quot;right&quot; of the pivot,
 // we add that subarray to the stack so we can sort it later
 if (pivotIndex + 1 &lt; end){
 stack.push(pivotIndex + 1);
 stack.push(end);
 }
 }
}
</code></pre>
Let's test this code on our example as well, by calling:
<pre><code class="hljs">ourArray = [7, -2, 4, 1, 6, 5, 0, -4, 2]
quickSortIterative(ourArray)

console.log(ourArray)
</code></pre>
We get the expected output of:
<pre><code class="hljs">-4,-2,0,1,2,4,5,6,7
</code></pre>
<h2 id="visualizationofquicksort">Visualization of Quick Sort</h2>
When it comes to sorting algorithms, it's always good to visualize them. It just helps us &quot;see&quot; them in action Here is an example of how the Quicksort algorithm works:
<img src="https://s3.stackabuse.com/media/articles/quicksort-in-javascript-2.gif" alt="Quick Sort Visualisation GIF">
 Source: <a rel="nofollow noopener" target="_blank" href="https://upload.wikimedia.org/wikipedia/commons/6/6a/Sorting_quicksort_anim.gif">Wikipedia</a>
In this case, the pivot is also taken as the last element. After the given array is partitioned, the left side is recursively gone through until it's completely sorted. Then the algorithm comes to the right side and does the sorting.
<h2 id="theefficiencyofquicksort">The Efficiency of Quick Sort</h2>
Now that we know how to implement the Quicksort algorithm let us discuss the time and space complexity. The worst-case time complexity of Quick Sort is O(n2). The average case time complexity is O(nlogn). The worst-case is usually avoided by using a randomized version of Quicksort.
The weak spot of the Quicksort algorithm is the choice of the pivot. Choosing a bad pivot (one that is greater than/less than most elements) every time, would give us the worst-case time complexity. While repeatedly choosing a pivot that has a roughly equal number of elements that are less than/greater than the pivot would give us a time complexity of O(nlogn).
Quicksort is one of those algorithms where the average-case runtime is actually important. Empirically, it was noticed that Quicksort tends to have a O(nlogn) runtime regardless of the pivot-choosing strategy.
Also, when it comes to space complexity, Quicksort doesn't take any extra space (excluding the space reserved for recursive calls). These kinds of algorithms are technically called as in-place algorithms. We don't need extra space because we are performing the operation on the same array.
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over the theory behind Quicksort and then implemented it recursively and iteratively using JavaScript.

In this article, we'll take a look at how to implement the Quicksort algorithm. We'll go through the recursive and iterative approach, and take a look at the efficiency of Quicksort.

Quicksort in JavaScript

<h2 id="introduction">Introduction</h2>
Matplotlib is one of the most widely used data visualization libraries in Python. Much of Matplotlib's popularity comes from its customization options - you can tweak just about any element from its hierarchy of objects.
In this tutorial, we'll take a look at how to change a figure size in Matplotlib.
<h2 id="creatingaplot">Creating a Plot</h2>
Let's first create a simple plot in a figure:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)
plt.show()
</code></pre>
Here, we've plotted a sine function, starting at <code>0</code> and ending at <code>10</code> with a step of <code>0.1</code>. Running this code yields:
<img src="https://stackabuse.s3.amazonaws.com/media/change-figure-size-in-matplotlib-1.png" alt="sine visualization python">
The <code>Figure</code> object, if not explicitly created, is created by default and contains all the elements we can and cannot see. Changing the size of the <code>Figure</code> will in turn change the size of the observable elements too.
Let's take a look at how we can change the figure size.
<h2 id="changefiguresizeinmatplotlib">Change Figure Size in Matplotlib</h2>
<h3 id="setthefigsizeargument">Set the figsize Argument</h3>
First off, the easiest way to change the size of a figure is to use the <code>figsize</code> argument. You can use this argument either in Pyplot's initialization or on an existing <code>Figure</code> object.
Let's first modify it during initialization:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.figure(figsize=(3, 3))
plt.plot(x, y)
plt.show()
</code></pre>
Here, we've accessed the <code>Figure</code> instance that was created by default and passed the <code>figsize</code> argument. Note that the size is defined in inches, not pixels. This will result in a figure that's 3in by 3in in size:
<img src="https://stackabuse.s3.amazonaws.com/media/change-figure-size-in-matplotlib-2.png" alt="changing size of figure with figsize">
Matplotlib/PyPlot don't currently support metric sizes, though, it's easy to write a helper function to convert between the two:
<pre><code class="hljs">def cm_to_inch(value):
 return value/2.54
</code></pre>
And then adjust the size of the plot like this:
<pre><code class="hljs">plt.figure(figsize=(cm_to_inch(15),cm_to_inch(10)))
</code></pre>
This would create a plot with the size of 15cm by 10cm:
<img src="https://stackabuse.s3.amazonaws.com/media/change-figure-size-in-matplotlib-3.png" alt="changing size in cm">
Alternatively, if you're creating a <code>Figure</code> object for your plot, you can assign the size at that time:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)
z = np.cos(x)

fig = plt.figure(figsize=(8, 6))

# Adds subplot on position 1
ax = fig.add_subplot(121)
# Adds subplot on position 2
ax2 = fig.add_subplot(122)

ax.plot(x, y)
ax2.plot(x, z)
plt.show()
</code></pre>
Here, we've explicitly assigned the return value of the <code>figure()</code> function to a <code>Figure</code> object. Then, we can add axes to this figure to create multiple subplots and plot on them.
We've used the <code>add_subplot()</code> function, which accepts a series of numerical values. The first number specifies how many rows you want to add to the figure, the second number specifies how many columns you want to add, and the third number specifies the number of the plot that you want to add.
This means that if you in passed in <code>111</code> into the <code>add_subplots()</code> function, one new subplot would be added to the figure. Meanwhile, if you used the numbers <code>221</code>, the resulting plot would have four axes with two columns and two rows - and the subplot you're forming is in the 1st position.
This code results in:
<img src="https://stackabuse.s3.amazonaws.com/media/change-figure-size-in-matplotlib-4.png" alt="adding subplots in matplotlib">
<h3 id="settheheightandwidthofafigureinmatplotlib">Set the Height and Width of a Figure in Matplotlib</h3>
Instead of the <code>figsize</code> argument, we can also set the height and width of a figure. These can be done either via the <code>set()</code> function with the <code>figheight</code> and <code>figwidth</code> argument, or via the <code>set_figheight()</code> and <code>set_figwidth()</code> functions.
The former allows you to write one line for multiple arguments while the latter provides you with code that's more readable.
Let's go with the second option:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)
z = np.cos(x)

fig = plt.figure()

fig.set_figheight(5)
fig.set_figwidth(10)

# Adds subplot on position 1
ax = fig.add_subplot(121)
# Adds subplot on position 2
ax2 = fig.add_subplot(122)

ax.plot(x, y)
ax2.plot(x, z)
plt.show()
</code></pre>
This code results in:
<img src="https://stackabuse.s3.amazonaws.com/media/change-figure-size-in-matplotlib-5.png" alt="setting the figure height and width in matplotlib">
Finally, you can also use the <code>set_size_inches()</code> function as well:
<pre><code class="hljs">fig = plt.figure()

fig.set_size_inches(10, 5)

# Adds subplot on position 1
ax = fig.add_subplot(121)
# Adds subplot on position 2
ax2 = fig.add_subplot(122)

ax.plot(x, y)
ax2.plot(x, z)
plt.show()
</code></pre>
And this performs the same as setting the <code>figsize</code> argument or using the two functions:
<img src="https://stackabuse.s3.amazonaws.com/media/change-figure-size-in-matplotlib-6.png" alt="setting figure size in inches in matplotlib">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to change the size of a figure in Matplotlib.
If you're interested in Data Visualization and don't know where to start, make sure to check out our book on <a class="ebook-link" href="https://gumroad.com/l/data-visualization-in-python">Data Visualization in Python</a>.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Limited time discount: 2-for-1, save 50%!
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with theses libraries - from simple plots to animated 3D plots with interactive buttons.
<blockquote>
It serves as an in-depth, guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
</blockquote>
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, cover core plotting libraries like Matplotlib and Seaborn, and show you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.
</blockquote>

In this tutorial, we'll go over how to change the size of a figure in Matplotlib. We'll use the figsize argument, as well as the set_figheight() and set_figwidth() functions on both regular axes and subplots.

Change Figure Size in Matplotlib

<h2 id="introduction">Introduction</h2>
Hoisting is a JavaScript behavior commonly known for making variables and functions available for use before the variable is assigned a value or the function is defined. In effect, it puts variable, function and class declarations to the top of their scope (the global scope or a function) before execution.
In actuality, JavaScript does not move or add code to hoist declarations. These declarations are put into memory during the compile phase of the interpreter - making them available before the code is executed.
In this article, we'll learn about hoisting and how it affects variables, functions and classes.
<h2 id="hoistingvariables">Hoisting Variables</h2>
One of the key aspects of hoisting is that the declaration is put into memory - not the value.
Let's see an example:
<pre><code class="hljs">console.log(name); // Prints undefined, as only declaration was hoisted
var name = &quot;John&quot;;
console.log(name); // Prints &quot;John&quot; 
</code></pre>
This happens because JavaScript sees that we have a variable <code>name</code> in the scope and puts it into memory. Variables declared with <code>var</code> are given a value of <code>undefined</code> until they are assigned something else.
<h3 id="variablehoistingwithletandconst">Variable Hoisting with let and const</h3>
JavaScript developers seldom use <code>var</code> in favor of the <code>let</code> and <code>const</code> keywords introduced in ECMAScript 2015 (commonly referred to as ES6). Variables declared with <code>let</code> and <code>const</code> are hoisted. However, they are not initialized with <code>undefined</code>, or any value. Therefore, if they are used before they initialized, we will get a <code>ReferenceError</code>.
Let's re-use the same example, but use <code>let</code> instead of <code>var</code>:
<pre><code class="hljs">console.log(name); // Uncaught ReferenceError: Cannot access &#x27;name&#x27; before initialization
let name = &quot;John&quot;;
console.log(name);
</code></pre>
The above code throws a <code>ReferenceError</code> in the first line and ends execution.
The <code>const</code> keyword was added to introduce immutable values in JavaScript - values which cannot be changed after it was initialized. As such, when using <code>const</code> we must declare and assign a value to the variable. If we do not, we'll get a <code>SyntaxError</code>:
<pre><code class="hljs">console.log(name); // Uncaught SyntaxError: Missing initializer in const declaration
const name;
</code></pre>
And like <code>let</code>, we get a <code>ReferenceError</code> when we try to use a constant before it was initialized:
<pre><code class="hljs">console.log(name); // Uncaught ReferenceError: Cannot access &#x27;name&#x27; before initialization
const name = &quot;John&quot;;
console.log(name);
</code></pre>
<h2 id="hoistingfunctions">Hoisting Functions</h2>
Function declarations are hoisted in JavaScript. A function declaration begins with the keyword <code>function</code>, followed by its name and arguments in brackets, and then its body. Let's consider the following code:
<pre><code class="hljs">let first_name = &quot;Stack&quot;;
let last_name = &quot;Abuse&quot;;

let result = concat(first_name, last_name);
console.log(result); // StackAbuse

function concat(x, y) {
 return x + y;
}
</code></pre>
As with variables, JavaScript puts the function into memory before executing the code in that scope. Therefore, hoisting allows us to call the <code>concat()</code> function before it is defined later in the code.
While function declarations are hoisted, function expressions don't work in the same way. A function expression is when we assign a variable to a function. For example, the code below will return an error:
<pre><code class="hljs">func_express(); // TypeError: func_express is not a function

var func_express = function () {
 console.log(&#x27;This the function expression is not a function&#x27;);
};
</code></pre>
JavaScript returns a <code>TypeError</code> because unlike function declaration, only the variable was hoisted. When variables declared with <code>var</code> are hoisted, they are given a default value of <code>undefined</code>. JavaScript then throws an error because the value of the variable is not a function at that point in time.
<h3 id="functionhoistingwitharrowfunctions">Function Hoisting with Arrow Functions</h3>
ECMA2015 introduced a new way to create anonymous functions, arrow functions. These are defined by a pair of brackets containing 0 or more arguments, an arrow <code>=&gt;</code> and the function body in curly braces. With regard to hoisting, they operate as other function expresses. For example:
<pre><code class="hljs">arrow_func_express(); // TypeError: arrow_func_express is not a function

var arrow_func_express = () =&gt; {
 console.log(&#x27;This the arrow function is not a function&#x27;);
};
</code></pre>
When using arrow functions, or any other function expression, we must always define the function before we use it in our code. This is the correct way to use a function expression:
<pre><code class="hljs">let arrow_func_express = () =&gt; {
 console.log(&#x27;This function expression will work&#x27;);
};

arrow_func_express(); // This function expression will work
</code></pre>
<h2 id="hoistingclasses">Hoisting Classes</h2>
Class declarations are hoisted in JavaScript. A class declaration is uninitialized when hoisted. That means, while JavaScript can find the reference for a class we create, it cannot use the class before it is defined in the code.
Let's take the following example which throws an error for trying to access a class before its definition:
<pre><code class="hljs">var person = new Person();
person.name = &quot;Jane&quot;;
person.age = 25;

console.log(person); // Uncaught ReferenceError: Cannot access &#x27;Person&#x27; before initialization&quot;

class Person {
 constructor(name, age) {
 this.name = name; this.age = age;
 }
}
</code></pre>
The <code>ReferenceError</code> is similar to what happens when we try to access a variable declared with <code>let</code> or <code>const</code> before it is initialized in our script.
Class expressions, where we assign a class definition to a variable, behave similarly to function expressions. Their declarations are hoisted but not their assigned value.
Let's take our previous example and use a class expression instead:
<pre><code class="hljs">var person = new Person();
person.name = &quot;Jane&quot;;
person.age = 25;

console.log(person); // Uncaught TypeError: Person is not a constructor&quot;

var Person = class {
 constructor(name, age) {
 this.name = name;
 this.age = age;
 }
}
</code></pre>
When the variable <code>Person</code> is hoisted, it is given the value <code>undefined</code>. Since we cannot use an <code>undefined</code> value as a class, JavaScript throws a <code>TypeError</code>.
When working with class declarations or class expressions, we should always define the class earlier in our code to use it. The correct way to use a class is as follows:
<pre><code class="hljs">class Person {
 constructor(name, age) {
 this.name = name; this.age = age;
 }
}

var person = new Person();
person.name = &quot;Jane&quot;;
person.age = 25;

console.log(stack); // Person { name: &#x27;Jane&#x27;, age: 25 }
</code></pre>
<h2 id="conclusion">Conclusion</h2>
JavaScript hoists, variable, function and class declarations. That article has shown the impacts hoisting has on how we write JavaScript code.
Function declarations can be used before their definition because of hoisting. However, to minimize our chances of getting <code>undefined</code> values as well as reference or type errors, it is safer to use variables, function expressions and classes after they are defined in our code.

Guest Contributor

Marcus Sanatan

In this article, we'll learn about the effects of hoisting - when JavaScript puts variable, function, and class declarations in memory before execution.

Hoisting in JavaScript

<h2 id="introduction">Introduction</h2>
With Spring, we map requests to request handlers via the <code>@RequestMapping</code> annotation. Spring Boot introduced us to derived types of this annotation - <code>@GetMapping</code>, <code>@PostMapping</code>, <code>@DeleteMapping</code>, etc.
These requests contain different types of information and data - and depending on what our endpoint does with the request, we may want to retrieve the body of a <code>POST</code> request either for logging or further processing.
The <code>@RequestBody</code> annotation allows us to retrieve the request's body. We can then return it as a String or deserialize it into a Plain Old Java Object (POJO).
Spring has built-in mechanisms for deserializing JSON and XML objects into POJOs, which makes this task a lot easier as well.
In this article, we'll get the body of a <code>POST</code> HTTP request and pack it into a String, as well as deserialize it into a POJO.
<h2 id="gettinghttppostbodyasastring">Getting HTTP POST Body as a String</h2>
Let's start out with a <code>@Controller</code> class to handle an incoming request:
<pre><code class="hljs">@ResponseBody
@Controller
@RequestMapping(&quot;/response&quot;)
public class HomeController {}
</code></pre>
What's worth noting here is that we've added the <code>@ResponseBody</code> annotation to the <code>@Controller</code>. This way, it won't render a template as the response body, but rather, will return a response body. Specifically, we'll pack it in a String and return that.
Spring Boot introduced us to another derived type - <code>@RestController</code> which is just a combination of the previous two annotations. Let's use that instead for brevity:
<pre><code class="hljs">@RestController
@RequestMapping(&quot;/response&quot;)
public class HomeController {}
</code></pre>
Now, let's go ahead and define a request handler. Since we're handling a <code>POST</code> request, we'll use the <code>@PostMapping</code> annotation for it:
<pre><code class="hljs">@RestController
@RequestMapping(&quot;/response&quot;)
public class HomeController {

 @PostMapping(&quot;/postbody&quot;)
 public String postBody(@RequestBody String fullName) {
 return &quot;Hello &quot; + fullName;
 }
}
</code></pre>
To retrieve the body of the <code>POST</code> request sent to the handler, we'll use the <code>@RequestBody</code> annotation, and assign its value to a String. This takes the body of the request and neatly packs it into our <code>fullName</code> String. We've then returned this name back, with a greeting message.
Let's test this controller out via <code>curl</code>:
<pre><code class="hljs">curl -X POST -H &quot;Content-type: application/json&quot; -d &quot;John Smith&quot; &quot;http://localhost:8080/response/postbody&quot;
</code></pre>
This results in:
<pre><code class="hljs">Hello John Smith
</code></pre>
<h2 id="deserializehttppostintopojo">Deserialize HTTP POST into POJO</h2>
Now, typically, we won't be working with Strings, although they serve as a good example for learning. In most cases, we'll want to do some processing, or at the least, serialize the request into a POJO. Let's define a <code>Person</code> POJO with a <code>firstName</code> and <code>lastName</code>:
<pre><code class="hljs">public class Person {
 private String firstName;
 private String lastName;
 
 // Constructor, getters and setters
}
</code></pre>
We'll perform the same process as in the previous example - with the same controller. However, this time, we'll specify that the controller is accepting JSON and XML values and that it produces JSON or XML responses back.
We'll retrieve a <code>POST</code> request body in JSON format, deserialize it into a POJO for further processing (saving into a database, for example) and return a JSON response.
Although Spring Boot can automatically match the JSON body to our POJO, given the variable names match, we'll explicitly set this option. We'll set the input and output formats using the <code>consumes</code> and <code>produces</code> flags in the <code>@PostMapping</code>:
<pre><code class="hljs">@RestController
@RequestMapping(&quot;/response&quot;)
public class HomeController {

 @PostMapping(
 value = &quot;/postbody&quot;,
 consumes = {MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE},
 produces = {MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE})
 public ResponseEntity&lt;Person&gt; postBody(@RequestBody Person person) {
 Person persistedPerson = personService.save(person);
 return ResponseEntity
 .created(URI
 .create(String.format(&quot;/persons/%s&quot;, person.getFirstName())))
 .body(persistedPerson);
 }
}
</code></pre>
Here, we're accepting JSON and XML, as well as producing it back. We've annotated the <code>Person</code> instance as the <code>@RequestBody</code>, which we'll also be expecting from the request. Then, we've used a <code>PersonService</code> instance to save the person to a database, which also returns the persisted object for further processing.
For brevity's sake, we've omitted the <code>PersonService</code> implementation as it's a standard service-layer implementation.
Finally, we've returned a <code>ResponseEntity</code> object. It's just an extension of the <code>HttpEntity</code> class that also has a status code. We've set the status code as <code>CREATED</code> with a <code>URI</code> location where the new created resource is located. Then, we've set the body of the <code>ResponseEntity</code> as the <code>persistentPerson</code> instance and built the response.
Let's test this controller out via <code>curl</code> again:
<pre><code class="hljs">curl -X POST -H &quot;Content-type: application/json&quot; -d &quot;{\&quot;firstName\&quot; : \&quot;John\&quot;, \&quot;lastName\&quot; : \&quot;Smith\&quot;}&quot; &quot;http://localhost:8080/response/postbody&quot;
</code></pre>
Here, we've made a <code>POST</code> request with a JSON body, containing the first and last name of a person and sent it to our endpoint. Jackson kicks off the deserialization process and maps the incoming JSON to our POJO:
<img src="https://s3.stackabuse.com/media/articles/spring-boot-get-http-post-body.png" alt="json to pojo mapping">
The endpoint, after saving the <code>Person</code> entity, responds with:
<pre><code class="hljs">{&quot;firstName&quot;:&quot;John&quot;,&quot;lastName&quot;:&quot;Smith&quot;}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've covered two ways to capture a <code>POST</code> HTTP request's body in a Spring Boot controller.
Using the <code>@RequestBody</code> annotation, we've mapped the body to a String and returned it. Afterwards, we've defined a POJO to deserialize incoming JSON contents into, processed it and finally returned a <code>ResponseEntity</code>.

In this article, we'll see how to get the HTTP POST body in Spring using the @RequestBody annotation and deserialize its JSON contents into a POJO for processing.

Get HTTP POST Body in Spring Boot with @RequestBody

<h2 id="introduction">Introduction</h2>
Websites generally need additional files such as images, CSS, and JavaScript files that are necessary to render complete web pages in a browser. In small projects, we can work our way around by providing absolute paths to our resources or by writing inline CSS and JavaScript functions in the HTML files. This is not only against the best coding practices but it also gets tricky when we are handling bigger projects, especially with multiple applications.
<blockquote>
In Django, the files required for interactive user experience, presentation of documents, and functional web pages are called static files.
</blockquote>
In this article, we will see how we can deal with multiple sets of static files provided by each application to customize the look and feel of a website.
<h2 id="configuringstaticfiles">Configuring Static Files</h2>
Django provides tremendous flexibility on how you can serve the static files. We will cover using the static files in local development as well as in production which is slightly more complex. First things first, let's do the basic configuration.
Django provides <a rel="nofollow noopener" target="_blank" href="https://docs.djangoproject.com/en/3.1/ref/contrib/staticfiles/#module-django.contrib.staticfiles"><code>django.contrib.staticfiles</code></a> to help you collect static files from each of your applications (and any other places you specify) into a single location that can easily be served in production.
In your <code>settings.py</code> file, your <code>INSTALLED_APPS</code> should look like this:
<pre><code class="hljs">INSTALLED_APPS = [
 &#x27;django.contrib.auth&#x27;,
 &#x27;django.contrib.sites&#x27;,
 &#x27;django.contrib.contenttypes&#x27;,
 &#x27;django.contrib.admin&#x27;,
 &#x27;django.contrib.sessions&#x27;,
 &#x27;django.contrib.messages&#x27;,
 &#x27;django.contrib.staticfiles&#x27;, # To serve static files
]
</code></pre>
<code>STATIC_ROOT</code> is the path that defines where your static files will be collected. We'll provide an absolute path to <code>STATIC_ROOT</code> in <code>settings.py</code>.
To do this, we'll use the <code>os</code> module's <code>dirname()</code> function to get the name of the directory we'd like to host these files in and define the path:
<pre><code class="hljs">import os

PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
STATIC_ROOT = os.path.join(PROJECT_ROOT, &#x27;staticfiles&#x27;)
</code></pre>
Then, you need to specify a <code>STATIC_URL</code> which is the URL used when referring to static files. It must end with <code>/</code> if it is set to any value except <code>None</code>. The following path means that static files will be stored in the location <code>http://localhost:8000/static/</code> or <code>http://127.0.0.1:8000/static/</code>:
<pre><code class="hljs">STATIC_URL = &#x27;/static/&#x27;
</code></pre>
Django has a list of finders as <a rel="nofollow noopener" target="_blank" href="https://docs.djangoproject.com/en/3.1/ref/settings/#std:setting-STATICFILES_FINDERS"><code>STATICFILES_FINDERS</code></a> that it uses to locate static files. One of the default finders is <code>AppDirectoriesFinder</code> that looks for a folder named <code>static</code> within each of your <code>INSTALLED_APPS</code>.
For example, if your project contains an application named <code>users</code>, you might create a directory such as <code>project_name/users/static/index.css</code> to add CSS files related to that app.
Even though this works, it is a better idea to create another subdirectory with your application name such as <code>project_name/users/static/users/index.css</code>. This is important when we have two or more static files with similar names.
Let's consider you have an <code>index.css</code> in every app each containing different CSS styles. Django will look for the first <code>index.css</code> it could find in <code>app/static/</code> directories. It will not be able to distinguish between various <code>index.css</code> that we have in each application's <code>static</code> directory. That is why we created a subdirectory with the application name <code>app/static/app/</code>.
Furthermore, most projects have multiple applications that can have common static files so it is usually better to make a folder <code>static</code> in your project's root directory instead of making a <code>static</code> folder in each application:
<img src="https://stackabuse.s3.amazonaws.com/media/serving-static-files-in-python-with-django-aws-s3-and-whitenoise-1.png" alt="static folder directory">
To use a commonplace for all static files in your project directory, we need to configure <code>STATICFILES_DIRS</code> to inform Django about our new directory because <code>AppDirectoriesFinder</code> will look for <code>static</code> in <code>app</code> directories only. We can also define multiple locations for our static files.
This is the place to define individual project's static folders if you have multiple ones:
<pre><code class="hljs">STATICFILES_DIRS = (
 os.path.join(PROJECT_ROOT, &#x27;static&#x27;),
 # Extra lookup directories for collectstatic to find static files
)
</code></pre>
Note that <code>STATICFILES_DIRS</code> will only work if you do not remove <code>FileSystemFinder</code> from <code>STATICFILES_FINDERS</code>.
As a brief recap, our <code>settings.py</code> include:
<pre><code class="hljs">import os

PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))
STATIC_ROOT = os.path.join(PROJECT_ROOT, &#x27;staticfiles&#x27;)
STATIC_URL = &#x27;/static/&#x27;

# Extra lookup directories for collectstatic to find static files
STATICFILES_DIRS = (
 os.path.join(PROJECT_ROOT, &#x27;static&#x27;),
)
</code></pre>
The static files are ready to be used in your project. We just need to load the <code>static</code> template tag by <code>{% load static %}</code> and then use the <code>static</code> template tag to build the URL for the given relative path. Let's see how we can use static files in our template file <code>base.html</code>:
<pre><code class="hljs">&lt;!doctype html&gt;
{% load static %}
&lt;html lang=&quot;en&quot;&gt;
 {% include &#x27;head.html&#x27; %}
 &lt;style&gt;
 body{
 background: url(&#x27;{% static &quot;bg.png&quot; %}&#x27;) no-repeat center center fixed; 
 -webkit-background-size: cover;
 -moz-background-size: cover;
 -o-background-size: cover;
 background-size: cover;
 }
 &lt;/style&gt;
 &lt;body&gt;
 &lt;div class=&quot;row justify-content-center&quot;&gt;
 &lt;div class=&quot;col-8&quot;&gt;
 &lt;h1 class=&quot;mainbtn&quot;&gt;MY CUSTOM CSS CLASS&lt;/h1&gt;
 {% block content %}
 &lt;hr class=&quot;mt-0 mb-4&quot;&gt;
 {% endblock %}
 &lt;/div&gt;
 &lt;/div&gt;
 &lt;/div&gt;
 &lt;/body&gt;
&lt;/html&gt;
</code></pre>
The <code>base.html</code> includes a <code>head.html</code> template for proper segregation as bigger projects usually contain lengthy code in <code>head</code> tags. The <code>mainbtn</code> class for <code>h1</code> is defined in the <code>static/index.css</code> file. The background image <code>bg.png</code> is also present in the <code>static</code> directory.
The <code>head.html</code> looks like this:
<pre><code class="hljs">&lt;head&gt;
 {% block css_block %}{% endblock %}
 {% load static %}
 &lt;meta charset=&quot;utf-8&quot;&gt;
 &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width, initial-scale=1, shrink-to-fit=no&quot;&gt;
 
 &lt;link rel=&quot;stylesheet&quot; href=&quot;{% static &#x27;css/index.css&#x27; %}&quot;&gt;
 &lt;script src=&quot;{% static &#x27;js/functions.js&#x27; %}&quot;&gt;&lt;/script&gt;
 &lt;script src=&quot;https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js&quot;&gt;&lt;/script&gt;
 
 &lt;title&gt;{% block title %} Title to be changed in included files {% endblock %}&lt;/title&gt;
&lt;/head&gt;
</code></pre>
<h3 id="servingstaticfiles">Serving Static Files</h3>
In addition to the above configurations, we also need to actually serve the static files. It is automatically done by Django's <code>runserver</code> command if <code>Debug = True</code>. You should use this method in the development phase as it is easy, however, it is not recommended for production because it is inefficient and insecure.
Django comes with a built-in command <code>collecstatic</code>. It compiles all static files into a single directory <code>STATIC_ROOT</code> which we already set. The final piece is the storage engine used when collecting static files with the <code>collectstatic</code> command. The storage engine can be configured by <code>STATICFILES_STORAGE</code>. Django has its own storage engine so the default value of <code>STATICFILES_STORAGE</code> is set to <code>django.contrib.staticfiles.storage.StaticFilesStorage</code>.
<h3 id="staticfilesinproduction">Static Files in Production</h3>
There are two main steps to put static files in a production environment:
<ul>
<li>Run the <code>collectstatic</code> command whenever the static files change</li>
<li>Arrange for <code>STATIC_ROOT</code> to be moved to the static file server and served</li>
</ul>
The <code>post_process()</code> method of the <code>Storage</code> class can take care of the second step but it really depends on your storage engine i.e. <code>STATICFILES_STORAGE</code>.
Note: You should know that serving static files in every production will be different due to the difference in environments but the basic idea and steps remain the same. There are three main tactics to handle the static files in production:
<ul>
<li>
Serve the static files and site from the same server: Use this method if you want your static files to be served from the server that is already running your web application. Despite its potential performance issue, it could be cost-effective as you only need to pay for one server hosting. To do this, push your code to the deployment server then run <code>collectstatic</code> to copy all files to <code>STATIC_ROOT</code>. Lastly, configure your webserver to serve the static files under <code>STATIC_URL</code>.
</li>
<li>
Serving static files from a dedicated server: The most common choices for dedicated static files servers are <a rel="nofollow noopener" target="_blank" href="https://nginx.org/en/">nginx</a> and <a rel="nofollow noopener" target="_blank" href="https://httpd.apache.org/">stripped-down version of Apache</a>. The web application runs on an entirely different server while your static files are deployed on a dedicated server which gives faster performance overall. Run <code>collectstatic</code> locally whenever static files change then push <code>STATIC_ROOT</code> to your dedicated server's directory that is being served. For detailed instructions, you should check the documentation of the respective server.
</li>
<li>
Serving static files from a cloud service: Another common tactic is to serve static files from a cloud storage provider such as Amazon, Microsoft Azure, and Alibaba Cloud.
</li>
</ul>
Let's see how we can use <a rel="nofollow noopener" target="_blank" href="https://aws.amazon.com/s3/">Amazon S3</a> for this purpose. First, install two Python libraries by using these commands:
<pre><code class="hljs">$ python -m pip install boto3
$ pip install django-storages
</code></pre>
The <code>boto3</code> library is a public API client to access Amazon S3 and other Amazon Web Services (AWS). The <code>django-storages</code> manages storage backends such as Amazon S3, OneDrive etc. It plugs in the built-in Django storage backend API. You will also need to add <code>storages</code> in your <code>INSTALLED_APPS</code>. Our <code>INSTALLED_APPS</code> like looks like this by now:
<pre><code class="hljs">INSTALLED_APPS = [
 &#x27;django.contrib.auth&#x27;,
 &#x27;django.contrib.sites&#x27;,
 &#x27;django.contrib.contenttypes&#x27;,
 &#x27;django.contrib.admin&#x27;,
 &#x27;django.contrib.sessions&#x27;,
 &#x27;django.contrib.messages&#x27;,
 &#x27;django.contrib.staticfiles&#x27;,
 &#x27;users&#x27;,
 &#x27;storages&#x27;, # New
]
</code></pre>
After that add the following configurations in your <code>settings.py</code>:
<pre><code class="hljs">AWS_ACCESS_KEY_ID = your_access_key_id
AWS_SECRET_ACCESS_KEY = your_secret_access_key
AWS_STORAGE_BUCKET_NAME = &#x27;sibtc-static&#x27;
AWS_S3_CUSTOM_DOMAIN = &#x27;%s.s3.amazonaws.com&#x27; % AWS_STORAGE_BUCKET_NAME
AWS_S3_OBJECT_PARAMETERS = {
 &#x27;CacheControl&#x27;: &#x27;max-age=86400&#x27;,
}
AWS_LOCATION = &#x27;static&#x27;
 
STATIC_URL = &#x27;https://%s/%s/&#x27; % (AWS_S3_CUSTOM_DOMAIN, AWS_LOCATION)
STATICFILES_STORAGE = &#x27;storages.backends.s3boto3.S3Boto3Storage&#x27;
</code></pre>
Finally, run <code>python manage.py collectstatic</code> and you are done with configuring Amazon S3 for your static files.
<h3 id="servingstaticfilesusingwhitenoise">Serving Static Files Using WhiteNoise</h3>
People often don't use third-party cloud services like Amazon S3 for a couple of reasons including paid subscriptions. WhiteNoise allows your Django project to serve its own static files, making it a self-contained unit that we can deploy anywhere without depending on service providers.
Although it works with any WSGI-compatible web application, it is most easily configured with a Django project.
<h4 id="configurationforwhitenoise">Configuration for WhiteNoise</h4>
Let's install <a rel="nofollow noopener" target="_blank" href="https://pypi.org/project/whitenoise/">WhiteNoise</a> with:
<pre><code class="hljs">$ pip install whitenoise
</code></pre>
In your <code>settings.py</code>, add WhiteNoise to the <code>MIDDLEWARE</code> list in the following order:
<pre><code class="hljs">MIDDLEWARE = [
 &#x27;django.middleware.security.SecurityMiddleware&#x27;,
 # WhiteNoise Middleware above all but below Security
 &#x27;whitenoise.middleware.WhiteNoiseMiddleware&#x27;, 
 &#x27;django.contrib.sessions.middleware.SessionMiddleware&#x27;,
 &#x27;django.middleware.common.CommonMiddleware&#x27;,
 &#x27;django.middleware.csrf.CsrfViewMiddleware&#x27;,
 &#x27;django.contrib.auth.middleware.AuthenticationMiddleware&#x27;,
 &#x27;django.contrib.messages.middleware.MessageMiddleware&#x27;,
 ]
</code></pre>
To use the compression support and forever-cacheable files, add this in your <code>settings.py</code> 
<code>STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'</code>
Run <code>python manage.py collectstatic</code>.
That's it! You can now deploy your web application to any hosting platform such as <a rel="nofollow noopener" target="_blank" href="https://www.heroku.com/python">Heroku</a>.
<h2 id="conclusion">Conclusion</h2>
Every website developer needs static files to make a beautiful and functional website. Django not only offers easy configuration of static files but also tremendous flexibility to play with their deployment.
In this article, we covered several ways to integrate static files in a Django web application in local development as well as production.

Muhammad Hashir Hassan

In this article, we take a look at how to serve static files using Django, including ing examples of serving static files locally and in production using AWS S3 and WhiteNoise.

Serving Static Files in Python With Django, AWS S3 and WhiteNoise

In this article, we'll explore how to lazy-load routes using Vue Router to improve page performance, as well as implement a progress bar to visualize the loading progress.

Lazy-Loading Routes with Vue Router

Lazy-Loading Routes with Vue Router with a Progress Bar

<h2 id="introduction">Introduction</h2>
The <code>cat</code> command is a Unix tool used for manipulating and displaying file contents. The command gets its name from the word &quot;concatenate&quot; because it has, among other things, the ability to concatenate files.
In this article, we'll go through a few easy ways to use this command to write text to a file with examples. Using <code>cat</code> is very straightforward, so no prior programming or Unix experience is needed to follow along.
<h2 id="catcommandbasics">cat Command Basics</h2>
Starting, we'll just sum up the basics of the <code>cat</code> command to help you out if you've never used it before or need a brief overview.
<h3 id="syntax">Syntax</h3>
The syntax looks like this:
<pre><code class="hljs">cat [OPTION]... [FILE]...
</code></pre>
To quickly look up the syntax or command options, run cat with the help option:
<pre><code class="hljs">$ cat --help
</code></pre>
Or, you can use the manual pages:
<pre><code class="hljs">$ man cat
</code></pre>
These commands should display the following list of options:
<pre><code class="hljs"> -A, --show-all equivalent to -vET
 -b, --number-nonblank number non empty output lines, overrides -n
 -e equivalent to -vE
 -E, --show-ends display $ at end of each line
 -n, --number number all output lines
 -s, --squeeze-blank suppress repeated empty output lines
 -t equivalent to -vT
 -T, --show-tabs display TAB characters as ^I
 -u (ignored)
 -v, --show-nonprinting use ^ and M- notation, except for LFD and TAB
 --help display this help and exit
 --version output version information and exit
</code></pre>
<h3 id="displayingfilecontentsonthestandardoutput">Displaying File Contents on the Standard Output</h3>
To print the contents of a file to the standard output just name the file you want to display:
<pre><code class="hljs">$ cat filename1 
</code></pre>
If the file is in a different directory, you'll have to navigate to it:
<pre><code class="hljs">$ cat /dir1/dir2/filename1 
</code></pre>
We'll be expecting to see the contents of this file, printed to the standard output, in this case - the terminal:
<pre><code class="hljs">Content of filename1!
</code></pre>
This is the most common use of the cat command since it makes it easy to peek into the contents of a file without opening a text editor.
<h2 id="writingtexttoafileusingcat">Writing Text to a File Using cat</h2>
To redirect the output of the <code>cat</code> command from the standard output to a file, we can use the output redirection operator <code>&gt;</code>:
<pre><code class="hljs">$ cat filename1 &gt; filename2
</code></pre>
This will overwrite the contents of <code>filename2</code> with the contents of <code>filename1</code>, so make sure that <code>filename2</code> doesn't contain anything you would mind losing. Now, <code>filename2</code> contains:
<pre><code class="hljs">Content of filename1!
</code></pre>
The output redirection operator will redirect the output of any command we call. For example, let's try it out with the <code>pwd</code> command, which prints the name of the current working directory:
<pre><code class="hljs">$ pwd &gt; testfile
</code></pre>
If we take a look at the <code>testfile</code> now:
<pre><code class="hljs">$ cat testfile
</code></pre>
It contains the current working directory's path:
<pre><code class="hljs">/home/kristina
</code></pre>
If the file you are redirecting to doesn't exist, a file by that name will be created:
<pre><code class="hljs">$ cat filename1 &gt; newfilename
</code></pre>
<h2 id="concatenatingfileswithcat">Concatenating Files with cat</h2>
Concatenating multiple files using <code>cat</code> is simple - just list the files in the desired order:
<pre><code class="hljs">$ cat filename1 filename2 &gt; outputfile
$ cat outputfile
</code></pre>
This takes the <code>filename1</code> and <code>filename2</code> files, concatenates them, and outputs the into a new <code>outputfile</code>:
<pre><code class="hljs">Content of filename1!
Content of filename2!
</code></pre>
<h2 id="standardinputbetweenfiles">Standard Input Between Files</h2>
When the name of the input file isn't listed, <code>cat</code> starts reading from the standard input until it reaches <code>EOF</code> (end-of-file). The end-of-file signal is sent by the <code>ctrl+d</code> command line shortcut:
<pre><code class="hljs">$ cat &gt; outputfile
Hello
World
$ cat outputfile
</code></pre>
This would output:
<pre><code class="hljs">Hello 
World
</code></pre>
We can even add text from the standard input in between files we wish to concatenate by using <code>-</code> to indicate where we expect standard input. If we have files such as <code>filename1</code>, <code>filename2</code>, and <code>filename3</code>, and we want some text from the standard input in between <code>filename1</code> and <code>filename2</code>, we would write:
<pre><code class="hljs"> $ cat filename1 - filename2 filename3 &gt; output
 Text from standard input!
 $ cat output
</code></pre>
Checking <code>output</code>, we'll see something along the lines of:
<pre><code class="hljs">Content of filename1!
Text from standard input!
Content of filename2!
Content of filename3!
</code></pre>
<h2 id="appendingfileswithcat">Appending Files with cat</h2>
In the previous examples, using the redirection operator discarded the previous contents of the <code>output</code> file. What if we want to append the new content to the old content? To append files we use the <code>&gt;&gt;</code> operator:
<pre><code class="hljs">$ cat filename1 filename2 &gt;&gt; output
$ cat output
</code></pre>
And that should result in:
<pre><code class="hljs">Original output file contents.
Content of filename1!
Content of filename2!
</code></pre>
<h2 id="concatenatingcontentsofallfilesdirectorywithcat">Concatenating Contents of all Files Directory with cat</h2>
To concatenate all contents of all files in a directory, we use the wildcard <code>*</code>:
<pre><code class="hljs">$ cat /dir1/dir2/* &gt; output
</code></pre>
To concatenate all contents of all files in the current working directory, we'd use:
<pre><code class="hljs">$ cat * &gt; output
</code></pre>
<code>*</code> can also be used to concatenate all files with the same extension:
<pre><code class="hljs">$ cat *.txt &gt; output
</code></pre>
<h2 id="enumeratinglinenumbers">Enumerating Line Numbers</h2>
Enumeration of all lines of output is done with the <code>-n</code> option:
<pre><code class="hljs">$ cat -n filename1 filename2 filename3 &gt; output
$ cat output
</code></pre>
Which would write something along the lines of:
<pre><code class="hljs"> 1 Content of filename1!
 2 Content of filename2!
 3 Content of filename3!
</code></pre>
<h2 id="writeattheendofeveryline">Write $ at the End of Every Line</h2>
The <code>-E</code> option marks the end of every line in the file with the <code>$</code> character:
<pre><code class="hljs">$ cat -E filename1 filename2 filename3 &gt; output
$ cat output
</code></pre>
<h2 id="sortinglinesofconcatenatedfilesbypiping">Sorting Lines of Concatenated Files by Piping</h2>
This one is a bit of a cheat. The <code>cat</code> command can't sort, but we can use piping to achieve that. The pipe command (<code>|</code>) is used to turn the output of one command into the input of another. To sort the lines of a file, we'll use both <code>cat</code> and another command, called <code>sort</code>:
<pre><code class="hljs">$ cat filename2 filename3 filename1 | sort &gt; output
$ cat output
</code></pre>
This results in:
<pre><code class="hljs">Content of filename1!
Content of filename2!
Content of filename3!
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Cat is a simple, yet powerful Unix tool that comes preinstalled on most systems. It can be used on its own or in combination with other commands using pipes. Originally made by Ken Thompson and Dennis Ritchie in 1971, <code>cat</code>'s easy to use and intuitive functionalities stand the test of time.
In this article, we've explored some of the possibilities of using the <code>cat</code> command to write text to files, check contents, concatenate and append files as well as enumerate lines and sort them.

Kristina Popovic

In this article, we'll be taking a look at the cat command on Linux. We'll explore how to write text to a file, read the input stream, append and concatenate files, as well as other operations.