<h2 id="introduction">Introduction</h2>
Dates are a really common data type developers work with. From timestamps of certain actions, to reports, sign up features and limited-time access in systems that require subscriptions - we oftentimes have to compare dates.
That is, we compare if a date is after or before another, if the date is today, how many days there are between dates, etc.
In this article, we'll take a look at how to compare two dates in JavaScript, helping us deduce whether a date is before or after another.
<h2 id="thedateobjectinjavascript">The Date Object in JavaScript</h2>
Web developers commonly use external packages (like <a rel="nofollow noopener" target="_blank" href="https://www.npmjs.com/package/moment">Moment.js</a>) to handle date-time operations. But, as the modern web evolved, JavaScript introduced a new object constructor called <code>Date</code> to handle date-time operations.
This means that you don't need an external library to perform rudimentary checks and operations, which makes it easier to perform these things in Vanilla JS.
The <code>Date</code> class is really simple to understand under the hood - it just stores Unix time measured in milliseconds.
<blockquote>
Unix time is measured as the number of seconds elapsed since the Unix epoch (00:00:00 UTC 1 January 1970), which is a completely arbitrary date.
</blockquote>
Even though this implementation seems a bit simplistic, the addition of the <code>Date</code> class was quite a big improvement, since there was finally a level of abstraction between developers and raw dates.
Now, let's look at different ways to compare two dates using <code>Date</code> objects.
<h2 id="comparingtwodatesinjavascript">Comparing Two Dates in JavaScript</h2>
We can use comparison operators like <code>&lt;</code> and <code>&gt;</code> to compare two <code>Date</code> objects, and under the hood, their time counters are effectively compared. You're effectively comparing two integer counters:
<pre><code class="hljs">function dateCompare(d1, d2){
 const date1 = new Date(d1);
 const date2 = new Date(d2);

 if(date1 &gt; date2){
 console.log(`${d1} is greater than ${d2}`)
 } else if(date1 &lt; date2){
 console.log(`${d2} is greater than ${d1}`)
 } else{
 console.log(`Both dates are equal`)
 }
}

dateCompare(&quot;6/11/2020&quot;, &quot;7/8/2019&quot;)
dateCompare(&quot;01/01/2021&quot;, &quot;01/01/2021&quot;)
</code></pre>
This results in:
<pre><code class="hljs">6/11/2020 is greater than 7/8/2019
Both dates are equal
</code></pre>
As we can see, comparing dates just boils down to converting the provided strings into <code>Date</code> objects and comparing them with an appropriate comparison operator.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: <a target="_blank" href="/javascript-loose-equality-operator-vs-strict-equality-operator/">Equality operators</a> (<code>==</code> and <code>===</code>) don't work with <code>Date</code> objects, so we don't explicitly check if they're the same.

 </div>
 </div>
 </div>
 Another way to compare two dates is by using the built-in <code>getTime()</code> method.
The <code>getTime()</code> method returns the number of milliseconds elapsed since the Unix epoch. Additionally, you can use the, <code>getDate()</code>, <code>getHours()</code>, <code>getDay()</code>, <code>getMonth()</code> and <code>getYear()</code> methods to further specify and compare information, amongst other similarly named methods.
Additionally, you can also use the <code>getUTCDay()</code>, <code>getUTCDate()</code>, <code>getUTCHour()</code>, <code>getUTCMinute()</code>, etc. methods, which return the given temporal identifiers, zoned specifically to UTC.
Note that with this approach, you can use equality operators!
Let's take a look at an example:
<pre><code class="hljs">function compareDates(d1, d2){
 const date1 = new Date(d1);
 const date2 = new Date(d2);

 if(date1.getTime() &gt; date2.getTime()){
 console.log(`${d1} is greater than ${d2} in terms of milliseconds`)
 } else if(date1.getYear() &lt; date2.getYear()){
 console.log(`${d2} is greater than ${d1} in terms of years`)
 } else if(date1.getDate() === date2.getDate()){
 console.log(`Both dates are equal`)
 }
}

compareDates(&quot;9/10/1997&quot;, &quot;9/10/2000&quot;)
compareDates(&quot;11/11/2021&quot;, &quot;11/1/2021&quot;)
</code></pre>
This results in:
<pre><code class="hljs">9/10/2000 is greater than 09/10/1997 in terms of years
11/11/2021 is greater than 11/1/2021 in terms of milliseconds
</code></pre>
Though, since we're working with <code>if</code> and <code>if-else</code> blocks, some statements never get to execute. For example, <code>9/10/1997</code> and <code>9/10/2000</code> have the same date, the <code>9/10</code>, though, not the same year.
For example, this code:
<pre><code class="hljs">function compareDates(d1, d2){
 const date1 = new Date(d1);
 const date2 = new Date(d2);
 
 if(date1.getDate() === date2.getDate()){
 console.log(`Both dates are equal`)
 }
}

compareDates(&quot;09/10/1997&quot;, &quot;9/10/2000&quot;)
</code></pre>
Would result in:
<pre><code class="hljs">Both dates are equal
</code></pre>
Since we're just comparing the date, without the year in mind.
<h2 id="conclusion">Conclusion</h2>
In this article, we've briefly gone over how JavaScript handles dates using <code>Date</code> objects. Then, we've covered how to compare dates in JavaScript, keeping some useful methods in mind.

Abhilash Kakumanu

In this tutorial, we'll go over how to compare dates in vanilla JavaScript, using the built-in methods and operators, with examples.

How to Compare Dates in JavaScript

Compare Two Dates in JavaScript

<h2 id="introduction">Introduction</h2>
Working with variables in data analysis always drives the question: How are the variables dependent, linked, and varying against each other? Covariance and Correlation measures aid in establishing this.
<blockquote>
Covariance brings about the variation across variables. We use covariance to measure how much two variables change with each other. Correlation reveals the relation between the variables. We use correlation to determine how strongly linked two variables are to each other.
</blockquote>
In this article, we'll learn how to calculate the covariance and correlation in Python.
<h2 id="covarianceandcorrelationinsimpleterms">Covariance and Correlation - In Simple Terms</h2>
Both covariance and correlation are about the relationship between the variables. Covariance defines the directional association between the variables. Covariance values range from -inf to +inf where a positive value denotes that both the variables move in the same direction and a negative value denotes that both the variables move in opposite directions.
Correlation is a standardized statistical measure that expresses the extent to which two variables are linearly related (meaning how much they change together at a constant rate). The strength and directional association of the relationship between two variables are defined by correlation and it ranges from -1 to +1. Similar to covariance, a positive value denotes that both variables move in the same direction whereas a negative value tells us that they move in opposite directions.
Both covariance and correlation are vital tools used in data exploration for feature selection and multivariate analyses. For example, an investor looking to spread the risk of a portfolio might look for stocks with a high covariance, as it suggests that their prices move up at the same time. However, a similar movement is not enough on its own. The investor would then use the correlation metric to determine how strongly linked those stock prices are to each other.
<h2 id="setupforpythoncoderetrievingsampledata">Setup for Python Code - Retrieving Sample Data</h2>
With the basics learned from the previous section, let's move ahead to calculate covariance in python. For this example, we will be working on the well-known <a href="https://www.kaggle.com/uciml/iris" target="_blank" rel="noopener nofollow">Iris dataset</a>. We're only working with the <code>setosa</code> species to be specific, hence this will be just a sample of the dataset about some <a href="https://www.google.com/search?tbm=isch&q=setosa" target="_blank" rel="noopener nofollow">lovely purple flowers</a>!
Let's have a look at the dataset, on which we will be performing the analysis:
<img src="https://stackabuse.s3.amazonaws.com/media/covariance-and-correlation-in-python-1.png" alt="Preview of the Iris dataset">
We are about to pick two columns, for our analysis - <code>sepal_length</code> and <code>sepal_width</code>.
In a new Python file (you can name it <code>covariance_correlation.py</code>), let's begin by creating two lists with values for the <code>sepal_length</code> and <code>sepal_width</code> properties of the flower:
<pre><code class="hljs">with open(&#x27;iris_setosa.csv&#x27;,&#x27;r&#x27;) as f:
 g=f.readlines()
 # Each line is split based on commas, and the list of floats are formed 
 sep_length = [float(x.split(&#x27;,&#x27;)[0]) for x in g[1:]]
 sep_width = [float(x.split(&#x27;,&#x27;)[1]) for x in g[1:]]
</code></pre>
In data science, it always helps to visualize the data you're working on. Here's a Seaborn regression plot (<a target="_blank" href="/seaborn-scatter-plot-tutorial-and-examples/">Scatter Plot</a> + linear regression fit) of these setosa properties on different axes:
<img src="https://stackabuse.s3.amazonaws.com/media/covariance-and-correlation-in-python-2.png" alt="Scatterplot of sepal_length and sepal_width">
Visually the data points seem to be having a high correlation close to the regression line. Let's see if our observations match up to their covariance and correlation values.
<h2 id="calculatingcovarianceinpython">Calculating Covariance in Python</h2>
The following formula computes the covariance:
<img src="https://stackabuse.s3.amazonaws.com/media/covariance-and-correlation-in-python-3.png" alt="Formula to calculate Covariance">
In the above formula,
<ul>
<li>xi, yi - are individual elements of the x and y series</li>
<li>x̄, y̅ - are the mathematical means of the x and y series</li>
<li>N - is the number of elements in the series</li>
</ul>
The denominator is <code>N</code> for a whole dataset and <code>N - 1</code> in the case of a sample. As our dataset is a small sample of the entire Iris dataset, we use <code>N - 1</code>.
With the math formula mentioned above as our reference, let's create this function in pure Python:
<pre><code class="hljs">def covariance(x, y):
 # Finding the mean of the series x and y
 mean_x = sum(x)/float(len(x))
 mean_y = sum(y)/float(len(y))
 # Subtracting mean from the individual elements
 sub_x = [i - mean_x for i in x]
 sub_y = [i - mean_y for i in y]
 numerator = sum([sub_x[i]*sub_y[i] for i in range(len(sub_x))])
 denominator = len(x)-1
 cov = numerator/denominator
 return cov

with open(&#x27;iris_setosa.csv&#x27;, &#x27;r&#x27;) as f:
 ...
 cov_func = covariance(sep_length, sep_width)
 print(&quot;Covariance from the custom function:&quot;, cov_func)
</code></pre>
We first find the mean values of our datasets. We then use a list comprehension to iterate over every element in our two series of data and subtract their values from the mean. A <code>for</code> loop could have been used as well, if that's your preference.
We then use those intermediate values of the two series' and multiply them with each other in another list comprehension. We sum the result of that list and store it as the <code>numerator</code>. The <code>denominator</code> is a lot easier to calculate, be sure to decrease it by 1 when you're finding the covariance for sample data!
We then return the value when the <code>numerator</code> is divided by its <code>denominator</code>, which results in the covariance.
Running our script would give us this output:
<pre><code class="hljs">Covariance from the custom function: 0.09921632653061219
</code></pre>
The positive value denotes that both the variables move in the same direction.
<h2 id="calculatingcorrelationinpython">Calculating Correlation in Python</h2>
The most widely used formula to compute correlation coefficient is <a target="_blank" href="/calculating-pearson-correlation-coefficient-in-python-with-numpy/">Pearson's</a> &quot;r&quot;:
<img src="https://stackabuse.s3.amazonaws.com/media/covariance-and-correlation-in-python-4.png" alt="Formula to calculate Correlation">
In the above formula,
<ul>
<li>xi, yi - are individual elements of the x and y series</li>
<li>The numerator corresponds to the covariance</li>
<li>The denominators correspond to the individual standard deviations of x and y</li>
</ul>
Seems like we've discussed everything we need to get the correlation in this <a href="/calculating-mean-median-and-mode-in-python/" target="_blank">series of articles</a>!
Let's calculate the correlation now:
<pre><code class="hljs">def correlation(x, y):
 # Finding the mean of the series x and y
 mean_x = sum(x)/float(len(x))
 mean_y = sum(y)/float(len(y))
 # Subtracting mean from the individual elements
 sub_x = [i-mean_x for i in x]
 sub_y = [i-mean_y for i in y]
 # covariance for x and y
 numerator = sum([sub_x[i]*sub_y[i] for i in range(len(sub_x))])
 # Standard Deviation of x and y
 std_deviation_x = sum([sub_x[i]**2.0 for i in range(len(sub_x))])
 std_deviation_y = sum([sub_y[i]**2.0 for i in range(len(sub_y))])
 # squaring by 0.5 to find the square root
 denominator = (std_deviation_x*std_deviation_y)**0.5 # short but equivalent to (std_deviation_x**0.5) * (std_deviation_y**0.5)
 cor = numerator/denominator
 return cor

with open(&#x27;iris_setosa.csv&#x27;, &#x27;r&#x27;) as f:
 ...
 cor_func = correlation(sep_length, sep_width)
 print(&quot;Correlation from the custom function:&quot;, cor_func)
</code></pre>
As this value needs the covariance of the two variables, our function pretty much works out that value once again. Once the covariance is computed, we then calculate the <a href="/calculating-variance-and-standard-deviation-in-python/" target="_blank">standard deviation</a> for each variable. From there, the correlation is simply dividing the covariance with the multiplication of the squares of the standard deviation.
Running this code we get the following output, confirming that these properties have a positive (sign of the value, either +, -, or none if 0) and strong (the value is close to 1) relationship:
<pre><code class="hljs">Correlation from the custom function: 0.7425466856651597
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we learned two statistical instruments: covariance and correlation in detail. We've learned what their values mean for our data, how they are represented in Mathematics and how to implement them in Python. Both of these measures can be very helpful in determining relationships between two variables.

Marcus Sanatan

Sathiya Sarathi Gunasekaran

Covariance and correlation are metrics that tell us how variables relate to each other. In this article, we'll learn how to implement them in Python.

Covariance and Correlation in Python

<h2 id="introduction">Introduction</h2>
In this article, we'll take a look at how to find the size of a dictionary in Python.
Dictionary size can mean its length, or space it occupies in memory. To find the number of elements stored in a dictionary we can use the <code>len()</code> function.
To find the size of a dictionary in bytes we can use the <code>getsizeof()</code> function of the <code>sys</code> module.
To count the elements of a nested dictionary, we can use a recursive function.
<h2 id="findingthesizeofthedictionary">Finding the Size of the Dictionary</h2>
The <code>len()</code> function is widely used to determine the size of objects in Python. In our case, passing a dictionary object to this function will return the size of the dictionary i.e. the number of key-value pairs present in the dictionary.
Because these objects keep track of their length, this operation has an O(1) time complexity:
<pre><code class="hljs">my_dict = {1: &quot;a&quot;, 2: &quot;b&quot;}
print(&quot;The length of the dictionary is {}&quot;.format(len(my_dict)))
</code></pre>
The above snippet returns this output:
<pre><code class="hljs">The length of the dictionary is 2
</code></pre>
<h2 id="findingthesizeofthedictionaryinbytes">Finding the Size of the Dictionary in Bytes</h2>
The memory size of the dictionary object in bytes can be determined by the <code>getsizeof()</code> function. This function is available from the <code>sys</code> module. Like <code>len()</code>, it can be used to find the size of any Python object.
This is particularly useful when we need code that needs to be performant, and/or requires regular monitoring. Let's take our previous example, and get a dictionary's size in bytes instead of the number of elements:
<pre><code class="hljs">import sys

my_dict = {1: &quot;a&quot;, 2: &quot;b&quot;}
print(&quot;The size of the dictionary is {} bytes&quot;.format(sys.getsizeof(my_dict)))
</code></pre>
The resulting output is:
<pre><code class="hljs">The size of the dictionary is 232 bytes
</code></pre>
<h2 id="findingthesizeofnesteddictionaries">Finding the Size of Nested Dictionaries</h2>
A nested dictionary is a dictionary inside a dictionary, or a dictionary with multiple levels of key-value pairs. These nested dictionaries help in simplifying complex structures like JSON responses from APIs.
These look something along the lines of:
<pre><code class="hljs">{&quot;dict1&quot;: {&quot;dict2&quot;: &quot;value 1&quot;}}
</code></pre>
Using the <code>len()</code> to get the count of all key-value pairings will not work as it gives the size of the object for the first level of keys only. To find the number of all the nested keys, we can write a custom recursive function to count the keys. This function would take a dictionary and a counter as arguments and iterate through each key.
For every iteration, the function checks if the instance of the key under consideration is a dictionary. If it's true, the function is recursively called again by appending the counter variable to <code>counter+1</code> and passing the dictionary under evaluation as arguments.
This recursive function will exist upon the complete iteration, returning the length of the dictionary as the variable: <code>counter</code>.
If the key isn't a dictionary instance, the counter is simply appended to <code>counter+1</code>. The function returns the <code>counter</code> value as a result of the iteration which gives the size of the dictionary under evaluation.
Hence, the count of the nested keys is evaluated using this function as shown below:
<pre><code class="hljs">def count_keys(dict_, counter=0):
 for each_key in dict_:
 if isinstance(dict_[each_key], dict):
 # Recursive call
 counter = count_keys(dict_[each_key], counter + 1)
 else:
 counter += 1
 return counter

my_dict = {
 &#x27;Name&#x27;:
 {
 &#x27;first_name&#x27;: &#x27;Sherlock&#x27;,
 &#x27;Last_name&#x27;: &#x27;Holmes&#x27;
 },
 &#x27;Locality&#x27;:
 {
 &#x27;Address&#x27;:
 {
 &#x27;Street&#x27;: &#x27;221B Baker Street&#x27;
 },
 &#x27;City&#x27;: &#x27;London&#x27;,
 &#x27;Country&#x27;: &#x27;United Kingdom&#x27;
 }
 }

print(&#x27;The length of the nested dictionary is {}&#x27;.format(count_keys(my_dict)))
</code></pre>
And when the snippet gets executed, we get the following output corresponding to the number of keys present in the dictionary:
<pre><code class="hljs">The length of the nested dictionary is 8
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we have explored the methods to calculate the size and length of dictionaries and nested dictionaries.
These functions can be very helpful in serving JSON objects over APIs: there are limits imposed by web servers for the size of JSON objects served over APIs and these functions can be used to keep the length and size in check.

In this article, you will learn how to get the size of a Python dictionary by length of key-value pairs and by size in bytes, with examples.

Python: Get Size of Dictionary

Guest Contributor

In this tutorial, we'll cover how to perform form data validation in Node.js with express-validator, a wrapper for the popular Validator.js library, with examples.

Form Data Validation in Node.js with express-validator

<h2 id="introduction">Introduction</h2>
<a rel="nofollow noopener" target="_blank" href="https://pandas.pydata.org/">Pandas</a> is a Python library for data analysis and manipulation. Almost all operations in <code>pandas</code> revolve around <code>DataFrame</code>s.
A <code>Dataframe</code> is is an abstract representation of a two-dimensional table which can contain all sorts of data. They also enable us give all the columns names, which is why oftentimes columns are referred to as attributes or fields when using <code>DataFrames</code>.
In this article we'll see how we can rename an already existing <code>DataFrame</code>'s columns.
There are two options for manipulating the column names of a <code>DataFrame</code>:
<ol>
<li>Renaming the columns of an existing <code>DataFrame</code></li>
<li>Assigning custom column names while creating a new <code>DataFrame</code></li>
</ol>
Let's take a look at both of the methods.
<h2 id="renamingcolumnsofanexistingdataframe">Renaming Columns of an Existing Dataframe</h2>
We have a sample <code>DataFrame</code> below:
<pre><code class="hljs">import pandas as pd
data = {&#x27;Name&#x27;:[&#x27;John&#x27;, &#x27;Doe&#x27;, &#x27;Paul&#x27;], 
 &#x27;age&#x27;:[22, 31, 15]} 
df = pd.DataFrame(data)
</code></pre>
The <code>DataFrame</code> <code>df</code> looks like this:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-rename-pandas-dataframe-column-in-python-1.png" alt="original pandas dataframe">
To rename the columns of this <code>DataFrame</code>, we can use the <code>rename()</code> method which takes:
<ol>
<li>A dictionary as the <code>columns</code> argument containing the mapping of original column names to the new column names as a key-value pairs</li>
<li>A <code>boolean</code> value as the <code>inplace</code> argument, which if set to <code>True</code> will make changes on the original <code>Dataframe</code></li>
</ol>
Let us change the column names in our <code>DataFrame</code> from <code>Name, age</code> to <code>First Name, Age</code>.
<pre><code class="hljs">df.rename(columns = {&#x27;Name&#x27; : &#x27;First Name&#x27;, &#x27;age&#x27; : &#x27;Age&#x27;}, inplace = True)
</code></pre>
Now, our <code>df</code> contains:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-rename-pandas-dataframe-column-in-python-2.png" alt="pandas dataframe rename column">
<h2 id="assigncolumnnameswhilecreatingadataframe">Assign Column Names While Creating a Dataframe</h2>
Now we will discuss how to assign column names while creating a <code>DataFrame</code>.
This is particularly helpful when you are creating a <code>DataFrame</code> from a <code>csv</code> file and want to ignore the header column names and assign your own.
By passing a list to the <code>names</code> argument, we can override the already existing header column with our own. The list must have a name for every column in the data, otherwise, an exception is thrown.
Note that if we want to rename only a few columns, it is better to use the <code>rename</code> method on the <code>DataFrame</code> after creating it.
We will be creating a <code>DataFrame</code> using <code>out.csv</code>, which has the following contents:
<pre><code class="hljs">Name, age
John, 22
Doe, 31
Paul, 15
</code></pre>
Note that the first line in the file is the header line and contains the column names. Pandas, by default, assigns the column names to the <code>DataFrame</code> from the first line.
Hence, we will specify to ignore the header line while creating our <code>DataFrame</code> and specify the column names in a list that is passed to the <code>names</code> argument:
<pre><code class="hljs">columns = [&#x27;First Name&#x27;, &#x27;Age&#x27;]
df = pd.read_csv(&#x27;out.csv&#x27;, header = None, names = columns)
df
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-rename-pandas-dataframe-column-in-python-2.png" alt="new dataframe changed column names">
Another way of doing this is by specifying the column names in the plain old <code>DataFrame()</code> constructor.
The one difference being that now the parameter that takes the list of column names is called <code>column</code> instead of <code>names</code>:
<pre><code class="hljs">import numpy as np

new_columns = [&#x27;First Name&#x27;, &#x27;Age&#x27;]
data = np.array([[&quot;Nicholas&quot;, 23],[&quot;Scott&quot;, 32],[&quot;David&quot;, 25]])

df = pd.DataFrame(data, columns = new_columns)
</code></pre>
This results in a different <code>DataFrame</code>:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-rename-pandas-dataframe-column-in-python-3.jpg" alt="dataframe constructor rename column">
<h2 id="conclusion">Conclusion</h2>
In this article we've quickly gone over how we can name and rename columns in <code>DataFrame</code>s. Either by assigning names while constructing the <code>DataFrame</code> instance, or by renaming them after the fact with the <code>rename()</code> method.

Hassan Saeed

In this tutorial, we'll go over how to rename a Pandas DataFrame Column in Python. We'll cover the rename() function as well as the creation of a new dataframe.

How to Rename Pandas DataFrame Column in Python

<h2 id="introduction">Introduction</h2>
<a rel="nofollow noopener" target="_blank" href="https://pandas.pydata.org/">Pandas</a> is a Python library for data analysis and manipulation. Almost all operations in <code>pandas</code> revolve around <code>DataFrame</code>s, an abstract data structure tailor-made for handling a metric ton of data.
In the aforementioned metric ton of data, some of it is bound to be missing for various reasons. Resulting in a missing (<code>null</code>/<code>None</code>/<code>Nan</code>) value in our <code>DataFrame</code>.
Which is why, in this article, we'll be discussing how to handle missing data in a Pandas <code>DataFrame</code>.
<h2 id="datainspection">Data Inspection</h2>
Real-world datasets are rarely perfect. They may contain missing values, wrong data types, unreadable characters, erroneous lines, etc.
The first step to to any proper data analysis is cleaning and organizing the data we'll later be using. We will discuss a few common problems related to data that might occur in a dataset.
We will be working with small employees dataset for this. The <code>.csv</code> file looks like this:
<pre><code class="hljs">First Name,Gender,Salary,Bonus %,Senior Management,Team
Douglas,Male,97308,6.945,TRUE,Marketing
Thomas,Male,61933,NaN,TRUE
Jerry,Male,NA,9.34,TRUE,Finance
Dennis,n.a.,115163,10.125,FALSE,Legal
,Female,0,11.598,,Finance
Angela,,,18.523,TRUE,Engineering
Shawn,Male,111737,6.414,FALSE,na
Rachel,Female,142032,12.599,FALSE,Business Development
Linda,Female,57427,9.557,TRUE,Client Services
Stephanie,Female,36844,5.574,TRUE,Business Development
,,,,,
</code></pre>
Let's import it into a <code>DataFrame</code>:
<pre><code class="hljs">df = pd.read_csv(&#x27;out.csv&#x27;)
df
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/python-how-to-handle-missing-dataframe-values-in-pandas-1.png" alt="original dataframe pandas">
Taking a closer look at the dataset, we note that Pandas automatically assigns <code>NaN</code> if the value for a particular column is an empty string <code>''</code> <code>NA </code> or <code>NaN</code>. However, there are cases where missing values are represented by a custom value, for example, the string <code>'na'</code> or <code>0</code> for a numeric column.
For example, the 6th row has a value of <code>na</code> for the <code>Team</code> column, while the 5th row has a value of <code>0</code> for the <code>Salary</code> column.
<h2 id="customizingmissingdatavalues">Customizing Missing Data Values</h2>
In our dataset, we want to consider these as missing values:
<ol>
<li>A <code>0</code> value in the <code>Salary</code> column</li>
<li>An <code>na</code> value in the <code>Team</code> column</li>
</ol>
This can be achieved by using the <code>na_values</code> argument to set custom missing values. This argument represents a dictionary where the keys represent a column name and the value represents the data values that are to be considered as missing:
<pre><code class="hljs"># This means that in Salary column, 0 is also considered a missing value.
# And &#x27;na&#x27; is considered a missing value in the Team column.
df = pd.read_csv(&#x27;out.csv&#x27;, na_values={&quot;Salary&quot; : [0], &quot;Team&quot; : [&#x27;na&#x27;]})
df
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/python-how-to-handle-missing-dataframe-values-in-pandas-2.png" alt="customized df">
On the other hand if we want to map a list of values which must be treated as missing values in all columns, we can pass a list of candidates which we want to globally consider as missing values to the <code>na_values</code> parameter:
<pre><code class="hljs">missing_values = [&quot;n.a.&quot;,&quot;NA&quot;,&quot;n/a&quot;, &quot;na&quot;, 0]
df = pd.read_csv(&#x27;out.csv&#x27;, na_values = missing_values)
df
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/python-how-to-handle-missing-dataframe-values-in-pandas-3.png" alt="global missing values pandas">
Note that here, the value of <code>Gender</code> in the 4th row is also <code>NaN</code> now since we defined <code>n.a.</code> as a missing value above.
Which implementation to chose depends upon the nature of the dataset.
For example, some of the numeric columns in the dataset might need to treat <code>0</code> as a missing value while other columns may not. Therefore, you can use the first approach where you customize missing values based on columns.
Likewise, if we want to treat <code>0</code> for example as a missing value globally, we can utilize the second method and just pass an array of such values to the <code>na_values</code> argument.
Once we have identified all the missing values in the <code>DataFrame</code> and annotated them correctly, there are several ways we can handle missing data.
<h2 id="removingrowswithmissingvalues">Removing Rows With Missing Values</h2>
One approach would be removing all the rows which contain missing values. This can easily be done with the <code>dropna()</code> function, specifically dedicated to this:
<pre><code class="hljs"># Drops all rows with NaN values
df.dropna(axis=0,inplace=True)
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/python-how-to-handle-missing-dataframe-values-in-pandas-6.png" alt="drop nan values pandas">
<code>inplace = True</code> makes all the changes in the existing <code>DataFrame</code> without returning a new one. Without it, you'd have to re-assign the <code>DataFrame</code> to itself.
The <code>axis</code> argument specifies if you're working with rows or columns - <code>0</code> being rows, and <code>1</code> being columns.
You can control whether you want to remove the rows containing at least 1 <code>NaN</code> or all <code>NaN</code> values by setting the <code>how</code> parameter in the <code>dropna</code> method.
how : {‘any’, ‘all’}
<ul>
<li><code>any</code>: if any NA values are present, drop that label</li>
<li><code>all</code>: if all values are NA, drop that label</li>
</ul>
<pre><code class="hljs">df.dropna(axis=0,inplace=True, how=&#x27;all&#x27;)
</code></pre>
This would only remove the last row from the dataset since <code>how=all</code> would only drop a row if all of the values are missing from the row.
Similarly, to drop columns containing missing values, just set <code>axis=1</code> in the <code>dropna</code> method.
<h2 id="fillingoutmissingvalues">Filling out Missing Values</h2>
It might not be the best approach to remove the rows containing missing values if such rows are abundant. They might contain valuable data in other columns and we don't want to skew the data towards an inaccurate state.
In this case, we have several options to assign appropriate values. The most common ones are listed below:
<ul>
<li>Fill NA with Mean, Median or Mode of the data</li>
<li>Fill NA with a constant value</li>
<li>Forward Fill or Backward Fill NA</li>
<li>Interpolate Data and Fill NA</li>
</ul>
Let's go through these one by one.
<h3 id="fillmissingdataframevalueswithcolumnmeanmedianandmode">Fill Missing DataFrame Values with Column Mean, Median and Mode</h3>
Let's start out with the <code>fillna()</code> method. It fills the NA-marked values with values you supply the method with.
For example, you can use the <code>.median()</code>, <code>.mode()</code> and <code>.mean()</code> functions on a column, and supply those as the fill value:
<pre><code class="hljs"># Using median
df[&#x27;Salary&#x27;].fillna(df[&#x27;Salary&#x27;].median(), inplace=True)
 
# Using mean
df[&#x27;Salary&#x27;].fillna(int(df[&#x27;Salary&#x27;].mean()), inplace=True)
 
# Using mode
df[&#x27;Salary&#x27;].fillna(int(df[&#x27;Salary&#x27;].mode()), inplace=True)
</code></pre>
Now, if a salary is missing from a person's rows, a mean, mode or median are used to fill that value. This way, you're not dropping these people from the dataset, and you're also not skewing the salary values.
While not perfect, this method allows you to introduce values that don't impact the overall dataset, since no matter how many averages you add, the average stays the same.
<h3 id="fillmissingdataframevalueswithaconstant">Fill Missing DataFrame Values with a Constant</h3>
You could also decide to fill the NA-marked values with a constant value. For example, you can put in a special string or numerical value:
<pre><code class="hljs">df[&#x27;Salary&#x27;].fillna(0, inplace=True)
</code></pre>
At the very least, these values are now actual values, instead of <code>na</code> or <code>NaN</code>.
<h3 id="forwardfillmissingdataframevalues">Forward Fill Missing DataFrame Values</h3>
This method would fill the missing values with first non-missing value that occurs before it:
<pre><code class="hljs">df[&#x27;Salary&#x27;].fillna(method=&#x27;ffill&#x27;, inplace=True)
</code></pre>
<h3 id="backwardfillmissingdataframevalues">Backward Fill Missing DataFrame Values</h3>
This method would fill the missing values with first non-missing value that occurs after it:
<pre><code class="hljs">df[&#x27;Salary&#x27;].fillna(method=&#x27;bfill&#x27;, inplace=True)
</code></pre>
<h3 id="fillmissingdataframevalueswithinterpolation">Fill Missing DataFrame Values with Interpolation</h3>
Finally, this method uses mathematical interpolation to determine what value would have been in the place of a missing value:
<pre><code class="hljs">df[&#x27;Salary&#x27;].interpolate(method=&#x27;polynomial&#x27;)
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Data cleaning and preprocessing is a very important part of every data analysis and each data science project.
In this article we went over several techniques to handle missing data which included customizing the missing data values and imputing the missing data values using different methods including mean, median, mode, a constant value, forward fill, backward fill and interpolation.

In this tutorial, we'll go over how to handle missing data in a Pandas DataFrame. We'll cover data cleaning as well as dropping and filling values using mean, mode, median and interpolation.

Python: How to Handle Missing Data in Pandas DataFrame

<h2 id="introduction">Introduction</h2>
Having to manually format a number as a currency string can be a tedious process. You may have just a few lines of modifications to make, however, when we need to do a fair bit of conversions, it becomes very tedious.
The first step to automating these kinds of tasks will require a function. In this article, we'll be going over a few methods you can use to format numbers as currency strings in Python.
<h2 id="methodsforformattingnumbers">Methods for Formatting Numbers</h2>
We'll be going over three alternate libraries and functions which allow us to convert numbers into currency strings:
<ul>
<li>The <a rel="nofollow noopener" target="_blank" href="http://babel.pocoo.org/en/latest/">locale</a> module.</li>
<li>The <a rel="nofollow noopener" target="_blank" href="https://docs.python.org/3/library/locale.html#locale.setlocale">Babel</a> module.</li>
<li>The <code>str.format()</code> function.</li>
</ul>
The <code>locale</code> module is already included in Python, though, we'll have to install Babel to use it.
<h2 id="formatnumberascurrencystringwithlocale">Format Number as Currency String with Locale</h2>
The <code>locale</code> module comes already preinstalled with your version of Python.
This package allows developers to localize their applications. Meaning they don't have to know in which region their software will be run, they can just write a universal codebase which will dynamically change depending on the region of use.
<h3 id="initializingthelocale">Initializing the Locale</h3>
To begin using the <code>locale</code> module you first need to set the locale:
<pre><code class="hljs">import locale 

# To use default settings, set locale to None or leave the second argument blank.
print(locale.setlocale(locale.LC_ALL, &#x27;&#x27;))

# To use a specific locale (Great Britain&#x27;s locale in this case)
print(locale.setlocale(locale.LC_ALL, &#x27;en_GB&#x27;))
</code></pre>
The code above will produce the following output:
<pre><code class="hljs">English_United States.1252
en_GB
</code></pre>
To get the list of available locales, you can look it up on <a rel="nofollow noopener" target="_blank" href="https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-lcid/70feba9f-294e-491e-b6eb-56532684c37f">MS-LCID</a>. Alternatively, you can print it out:
<pre><code class="hljs"># For the Windows operating system 
for lang in locale.windows_locale.values():
 print(lang)

# For other operating systems
for lang in locale.locale_alias.values():
 print(lang)
</code></pre>
Running any of the above variants will yield something similar to:
<pre><code class="hljs">en_GB
af_ZA
sq_AL
gsw_FR
am_ET
ar_SA
ar_IQ
ar_EG
ar_LY
ar_DZ
...
</code></pre>
<h3 id="formattingnumberswithlocale">Formatting Numbers with Locale</h3>
With your preferred locale set, you can easily format number strings:
<pre><code class="hljs">locale.setlocale(locale.LC_ALL, &#x27;&#x27;)

# If you&#x27;d like groupings - set grouping to True, else set it to false or leave it out completely
print(locale.currency(12345.67, grouping=True))
print(locale.currency(12345.67))
</code></pre>
Running the code above we get the following output:
<pre><code class="hljs">$12,345.67
$12345.67
</code></pre>
<h2 id="usingthestrformatmethod">Using the str.format() method</h2>
The next method we'll be covering is the <code>str.format()</code> method, which has the advantage of being the most straightforward one:
<pre><code class="hljs">number_string = 340020.8
# This portion is responsible for grouping the number
number_commas_only = &quot;{:,}&quot;.format(number_string)
print(number_commas_only)

# To ensure we have two decimal places
number_two_decimal = &quot;{:.2f}&quot;.format(number_string)
print(number_two_decimal)

# Both combined along with the currency symbol(in this case $)
currency_string = &quot;${:,.2f}&quot;.format(number_string)
print(currency_string)
</code></pre>
Running the code above we get the following output:
<pre><code class="hljs">340,020.8
340020.80
$340,020.80
</code></pre>
Though, this approach is hard-coded, unlike the previous one, which you can use to localize the formatting dynamically.
<h2 id="formatnumberascurrencystringwithbabel">Format Number as Currency String with Babel</h2>
Using Babel is perhaps one of the lesser known methods, however it's very user-friendly and intuitive. It comes with number and currency formatting as well as other internationalizing tasks.
Unlike Python's <code>locale</code> module, you don't have to worry about making adjustments on a global scale.
To install <code>Babel</code> via <code>pip</code>, run the following command:
<pre><code class="hljs">$ pip install Babel
...
Successfully installed Babel-2.9.0
</code></pre>
Once installed, to achieve the same results as the two other methods listed above, you can simply call <code>format_currency()</code> on a string:
<pre><code class="hljs">import babel.numbers
number_string = 340020.8

# The three needed arguments are the number, currency and locale
babel.numbers.format_currency(number_string, &quot;USD&quot;, locale=&#x27;en_US&#x27;)
</code></pre>
Running the code above we get the following output:
<pre><code class="hljs">$340,020.80
</code></pre>
To get the full list of locales available:
<pre><code class="hljs">avail_loc = babel.localedata.locale_identifiers()
print(avail_loc)
</code></pre>
Which looks something like this:
<pre><code class="hljs">[&#x27;af&#x27;, &#x27;af_NA&#x27;, &#x27;af_ZA&#x27;, &#x27;agq&#x27;, &#x27;agq_CM&#x27;, &#x27;ak&#x27;, &#x27;ak_GH&#x27;, &#x27;am&#x27;, &#x27;am_ET&#x27;,...]
</code></pre>
<h2 id="searchingfornumbersinstringsandformattingascurrency">Searching For Numbers in Strings and Formatting as Currency</h2>
Sometimes, you don't work with direct numerical input, such as the input from a user. You might be working with a sentence, or a larger, unclean corpus. We can use the <code>re</code> module to filter through different types of input, find numerical values and format them.
Let's use all three of the approaches above to format the currency in a sentence:
<pre><code class="hljs">import re
import locale
import babel.numbers
locale.setlocale(locale.LC_ALL, &#x27;en_US&#x27;)
</code></pre>
Next we come up with the regex pattern needed to match the number strings:
<pre><code class="hljs"> # This pattern is used to match any number string
 pattern = r&#x27;\d+(\.\d{1,2})?&#x27;
</code></pre>
Next we apply the three methods we've learned to the string variable <code>message</code>:
<pre><code class="hljs">message = &quot;Our current budget is 180000, we&#x27;ll need 25000.67 to cover rent, then 23400.4 for food.&quot;

# re.sub() is used to substitute substrings that match a certain pattern
# with another string, in our case the return value of a lambda function
# which will return a matching currency string.
new_message_locale = re.sub(
 pattern, lambda x: locale.currency(float(x.group()), grouping=True), message
)
new_message_str = re.sub(
 pattern, lambda x: &quot;${:,.2f}&quot;.format(float(x.group())), message
)
new_message_babel = re.sub(
 pattern,
 lambda x: babel.numbers.format_currency(float(x.group()), &quot;USD&quot;, locale=&quot;en_US&quot;),
 message,
)
</code></pre>
Let's compare the original output with the output gotten from all three methods:
<pre><code class="hljs">print(message)
print(new_message_locale)
print(new_message_str)
print(new_message_babel)
</code></pre>
<pre><code class="hljs">Our current budget is 180000, we&#x27;ll need 25000.67 to cover rent, then 23400.4 for food.
Our current budget is $180,000.00, we&#x27;ll need $25,000.67 to cover rent, then $23,400.40 for food.
Our current budget is $180,000.00, we&#x27;ll need $25,000.67 to cover rent, then $23,400.40 for food.
Our current budget is $180,000.00, we&#x27;ll need $25,000.67 to cover rent, then $23,400.40 for food.
</code></pre>
Depending on the method you prefer, the length of this script can be reduced. There are certain limitations as you may have noticed.
The script as it is, is unable to differentiate between number strings you'd like to format. However, it can be changed easily depending on your needs and use cases.
<h2 id="conclusion">Conclusion</h2>
In this article we took a look at a couple of ways of converting numbers into proper currency strings. We've covered the <code>str.format()</code> method, as well as the <code>locale</code> and <code>babel</code> modules.
Finally we combined these methods with Python's regular expression module to achieve a wider range of uses. In the end I hope you were able to learn something new from all this that can help save you time.

Daniel Pimeh

In this tutorial, we'll cover how to format a number as a currency string in Python, using the built-in str.format() method, the locale module and the Babel module.

How to Format Number as Currency String in Python

<h2 id="introduction">Introduction</h2>
Server logs are an important part of development that record the activities or events that the system is performing at any given point in time.
Spring Boot makes use of <a rel="nofollow noopener" target="_blank" href="https://commons.apache.org/proper/commons-logging/">Apache Commons' Logging</a> for its system logs by default. Additionally, by default you can use any of the logging frameworks under the <a rel="nofollow noopener" target="_blank" href="http://www.slf4j.org/docs.html">SLF4J API</a> such as Logback (which is the default), Log4J2, and Java Util Logging in Spring Boot.
Application logging is a powerful development tool that is important for production-level support and debugging. Each log entry contains information such as the timestamp, the actual method being called, a custom log message, and other contextual information. Each log entry also includes an identifier called a logging level.
In this tutorial, we'll take a look at how to perform Logging in Spring Boot, using SLF4J, as well as log levels and the configuration required to customize them, and log groups.
<h2 id="logmessagesinspringboot">Log Messages in Spring Boot</h2>
To enable logging in Spring, import <code>Logger</code> and <code>LoggerFactory</code> from the <code>org.slf4j</code> API library:
<pre><code class="hljs">import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
</code></pre>
Afterwards, declare a constant to store the logger service by instantiating a logger for the class using <code>LoggerFactory</code>:
<pre><code class="hljs">private static final Logger log = LoggerFactory.getLogger(DemoService.class);
</code></pre>
This <code>log</code> is usually defined at the very top of the global variable list, since it's a constant. By providing the class you want to log, it's fully set up and ready to be called with the provided messages.
Alternatively, you can just annotate the class with <code>@Slf4j</code> which will automatically generate a logger for the class without having to declare a constant. The annotation supplies a static variable called <code>log</code> which provides the logger utilities by default:
<pre><code class="hljs">@Slf4j
@Service
public class DemoService {
 //...
}
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: The most common identifier for the logger is <code>log</code>, though you'll also see <code>logger</code> in a lot of cases. Really, you're free to call it whatever you'd like, but <code>log</code> is succinct and saves you from writing a longer name due to frequent calls.

 </div>
 </div>
 </div>
 Logging in Spring Boot comprises a few different levels. Every log has a degree of urgency or importance that is associated with a log level. Log levels are configured at runtime and each log request checks the log level to see if the request has equal or higher priority than the log level to be displayed.
If you try logging a message which is considered less important than some threshold, it just won't be logged.
Take this block for example, with messages of log importance in descending order:
<pre><code class="hljs">public void logLevelDisplay () {
 logger.error(&quot;Error message&quot;);
 logger.warn(&quot;Warning message&quot;);
 logger.info(&quot;Info message&quot;);
 logger.debug(&quot;Debug message&quot;);
 logger.trace(&quot;Trace message&quot;);
}
</code></pre>
If no configurations are set in <code>application.properties</code> or elsewhere, the log level will default to <code>INFO</code>. So if we were to call the method <code>logLevelDisplay()</code>, it would output something like this:
<pre><code class="hljs">2020-12-20 12:46:35.880 ERROR 47958 --- [nio-8080-exec-1] c.service.DemoService : Error message
2020-12-20 12:46:52.976 WARN 47958 --- [nio-8080-exec-1 c.service.DemoService : Warn message
2020-12-20 12:46:59.104 INFO 47958 --- [nio-8080-exec-1] c.service.DemoService : Info message
</code></pre>
The <code>DEBUG</code> and <code>TRACE</code> messages weren't displayed because the application's log level is set to <code>INFO</code>, which has a higher priority level than the two.
If the log level was set to <code>ERROR</code>, then only the error message would be displayed since it's the highest log level of the 5 built-in levels.
This brings us to an important topic - log levels, which deserve an explanation of their own.
<h2 id="loglevelsinspringboot">Log Levels in Spring Boot</h2>
As mentioned before, logging in Spring Boot comprises different levels. For example, Hibernate SQL queries are categorized as <code>DEBUG</code>, which is a low-urgency log level that is mainly invoked for debugging purposes.
Logging levels allows distinction between the following sample logs:
<ul>
<li>Successfully updated <code>User</code> information: Updated name <code>John</code> to <code>Jon</code>.</li>
<li>NullPointerException: <code>id</code> of <code>User</code> is <code>null</code></li>
</ul>
The first log is a general informative type of message while the second log is a <code>NullPointerException</code> message.
These logs have different levels of urgency, and distinction between them using log levels is important for filtering out logs that don't have to be output depending on the circumstance. If there's a huge error going on, you don't want it to be cluttered by a bunch of working, low-level <code>INFO</code> logs!
SLF4J provides 5 default logging levels in Spring boot:
<code>ERROR</code> - Error logs are serious issues that affect a significant part of the system or some part of your application has failed to operate. Exceptions are considered <code>ERROR</code> level logs. Other examples of error logs are database connection failures and configuration errors. <code>ERROR</code> logs are the most urgent default log level in SLF4J.
<code>WARN</code> - Warning logs are used to indicate potential problems that might cause errors and should be monitored in case they fail. Of course, the context of a warning is subjective to the developer and the situation so warning logs might vary from system to system.
<code>INFO</code> -<code>INFO</code> is the default logging level that is set by Spring Boot. If no configurations are made, the log level is automatically set to <code>INFO</code>. These types of logs are information that isn't normally needed but is useful in situations like production code debugging or determining when certain data is manipulated.
<code>DEBUG</code> - <code>DEBUG</code> logs include more detailed, specific information that isn't needed in normal situations. This is often set as a log level when a developer is trying to deep trace a problem or a bug that is hard to trace.
<code>TRACE</code> - <code>TRACE</code> is a more granular version of <code>DEBUG</code>. <code>TRACE</code> logs are exhaustive, imagine logging every single operation the system is doing, from starting a service, initializing new variables, and calling methods.
In order of urgency, <code>ERROR</code> is the most urgent while <code>TRACE</code> is the least urgent log. The default log level in Spring Boot is <code>INFO</code> when no manual configuration is set.
<h2 id="configuringloglevelsinspringboot">Configuring Log Levels in Spring Boot</h2>
Log levels can be set in the Spring environment by setting its configurations in <code>application.properties</code>.
The format to set the log level configuration is <code>logging.level.[classpath] = [level]</code>. The classpath is specified since different components of the application can be configured with different log levels, which is especially useful for code isolation and debugging.
To specify a log level for all classes that don't have their own log level settings, the <code>root</code> logger can be set using <code>logging.level.root</code>.
In <code>application.properties</code>:
<pre><code class="hljs">logging.level.root=INFO
logging.level.com.test=DEBUG
logging.level.com.service.DemoService=WARN
</code></pre>
From this configuration, every class except <code>DemoService</code> and the classes under the <code>com.test</code> classpath will have their log levels set to <code>INFO</code>, while the <code>test</code> classes and <code>DemoService</code> have their own specified log levels.
<h2 id="loggroups">Log Groups</h2>
Log groups is a useful way to set logger configurations to a group of classes with different classpaths. An example is if you want to set all the test class log levels to <code>DEBUG</code> in one go. This is possible using the configuration <code>logging.group.[groupName]</code>:
<pre><code class="hljs"># Initialize log group
logging.group.test=com.test, com.test-prod, com.apptest

# Set log level to log group
logging.level.test=DEBUG
</code></pre>
With this approach, you won't have to individually set the log level of all related components all the time.
<h2 id="conclusion">Conclusion</h2>
Knowing about the different log levels is important especially in situations like debugging in production.
Let's say a major bug has been exposed in production, and the current logs do not have enough information to diagnose the root cause of the problem. By changing the log level to <code>DEBUG</code> or <code>TRACE</code>, the logs will show much-needed information to pinpoint crucial details that may lead towards the fix.
In Spring, the log level configurations can be set in the <code>application.properties</code> file which is processed during runtime. Spring supports 5 default log levels, <code>ERROR</code>, <code>WARN</code>, <code>INFO</code>, <code>DEBUG</code>, and <code>TRACE</code>, with <code>INFO</code> being the default log level configuration.

David Landup

Rayven Yor Esplanada

In this tutorial, we'll cover how to log in Spring Boot with SLF4J. We'll cover log levels, log groups and the default Logback logger with examples.

Logging in Spring Boot with SLF4J

<h2 id="introduction">Introduction</h2>
Most web applications nowadays will require you to fill out a form at some point, be it an online banking application or a music streaming service.
And because end users are never to be trusted, we need to fool-proof our application so that it detects when the input is incorrect and returns it back to the user with an appropriate (error) message.
Form validation is a technique used to prevent users from providing data that does not meet the requirements of the application. An example would be making sure that the provided password has at least one uppercase character and a number. You can validate data on the server-side, or the client-side.
Server-side validation is the idea of validating user data after it is sent to the servers. If the data is not in the expected format, it is sent back to the user.
On the other hand, client-side validation entails validating the data input by the user in the browser before it is sent to the server. This is typically more efficient than server-side validation since it prevents the round trip from the client to server and back. It's also an early filter, which makes sure that the right data gets through, instead of dealing with the wrong data once it has been passed through.
This doesn't mean that the server shouldn't have data validation - we're just sifting through initially now.
In this tutorial, we will discuss how we can validate data in the browser using vanilla JavaScript.
<h2 id="creatingaform">Creating a Form</h2>
Let's make a simple sign-up form, which will will consist of the following fields:
<ol>
<li><code>username</code></li>
<li><code>first-password</code> - used to check the initial password for certain criteria</li>
<li><code>second-password</code> - used as confirmation, and making sure the user didn't make a typo in the <code>first-password</code> field.</li>
</ol>
... and put it into our <code>index.html</code> file:
<pre><code class="hljs">&lt;!DOCTYPE html&gt;
&lt;html lang=&quot;en&quot;&gt;
 &lt;head&gt;
 &lt;meta charset=&quot;UTF-8&quot; /&gt;
 &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width, initial-scale=1.0&quot; /&gt;

 &lt;script defer src=&quot;validate.js&quot;&gt;&lt;/script&gt;

 &lt;title&gt;Form Validation&lt;/title&gt;
 &lt;/head&gt;
 &lt;body&gt;
 &lt;h1&gt;Form Validation Using JavaScript&lt;/h1&gt;

 &lt;form id=&quot;form&quot; action=&quot;/&quot; method=&quot;GET&quot;&gt;
 &lt;!-- We are only interested in client-side validation now --&gt;

 &lt;!-- All the fields are required --&gt;
 &lt;div&gt;
 &lt;label for=&quot;username&quot;&gt;Username: &lt;/label&gt;
 &lt;input type=&quot;text&quot; name=&quot;username&quot; id=&quot;username&quot; autofocus required /&gt;
 &lt;/div&gt;

 &lt;div&gt;
 &lt;label for=&quot;first-password&quot;&gt;Password: &lt;/label&gt;
 &lt;input
 type=&quot;password&quot;
 name=&quot;firstPassword&quot;
 id=&quot;first-password&quot;
 required
 /&gt;
 &lt;/div&gt;

 &lt;div&gt;
 &lt;label for=&quot;second-password&quot;&gt;Confirm Password: &lt;/label&gt;
 &lt;input
 type=&quot;password&quot;
 name=&quot;secondPassword&quot;
 id=&quot;second-password&quot;
 required
 /&gt;
 &lt;/div&gt;

 &lt;button type=&quot;submit&quot;&gt;Submit&lt;/button&gt;
 &lt;/form&gt;

 &lt;div id=&quot;show-error&quot;&gt;No validation error yet!&lt;/div&gt;
 &lt;!--We will use this div to display validation error --&gt;
 &lt;/body&gt;
&lt;/html&gt;
</code></pre>
This HTML file will render a simple form which looks like this:
<img src="https://stackabuse.s3.amazonaws.com/media/client-side-form-validation-using-vanilla-javascript-1.jpg" alt="">
<h2 id="formrequirements">Form-Requirements</h2>
Before writing any code, let's first go over the list of validations we need:
<ul>
<li>Make sure the username starts with an uppercase letter</li>
<li>The username must have at least one digit included</li>
<li>Ensure the password length is between 8 to 20 characters</li>
<li>Make sure the password contains at least one uppercase letter</li>
<li>Confirm the two passwords match</li>
</ul>
In case the user input isn't compliant with the requirements above, we want:
<ul>
<li>The text of the last <code>div</code> to change</li>
<li>Prevent the form from submitting</li>
</ul>
<h2 id="setup">Setup</h2>
First, let's make a script file <code>validate.js</code> and link it with our <code>index.html</code> file inside our <code>head</code> tag:
<pre><code class="hljs">&lt;script defer src=&quot;validate.js&quot;&gt;&lt;/script&gt;
</code></pre>
Then, let's access the relevant fields from the document:
<pre><code class="hljs">// To disable the form from submitting
const form = document.querySelector(&#x27;#form&#x27;);
// To display the error message
const errorDiv = document.querySelector(&#x27;#show-error&#x27;);
// To validate the username
const username = document.querySelector(&#x27;#username&#x27;);
// To validate the password
const firstPassword = document.querySelector(&#x27;#first-password&#x27;);
// To confirm the password
const secondPassword = document.querySelector(&#x27;#second-password&#x27;); 
</code></pre>
For the sake of simplicity, let's make it so that the form validations are only run upon clicking the <code>submit</code> button, and not in real-time:
<pre><code class="hljs">form.addEventListener(&#x27;submit&#x27;, (error) =&gt; {
 // All validation checks are run in this method. 
}
</code></pre>
<h2 id="implementingthevalidators">Implementing the Validators</h2>
<h3 id="firstletteroftheusernameisuppercase">First Letter of the Username is Uppercase</h3>
This is pretty self explanatory, if the string's first letter is the same as its uppercase variant, it means that <code>username</code> in fact starts with an uppercase letter:
<pre><code class="hljs">// We will include any and all errors in this string
let incorrectInput = &#x27;&#x27;;

const firstLetter = username.value[0];

// Return true if first letter is uppercase
const firstLetterIsUpperCase = (firstLetter === firstLetter.toUpperCase()); 

if (!firstLetterIsUpperCase) {
 incorrectInput += &#x27; The first letter of username must be uppercase.\n&#x27;;
}
</code></pre>
<h3 id="usernamecontainsatleastonedigit">Username Contains at Least One Digit</h3>
<code>/\d/</code> is a regular expression pattern that matches to a single digit, meaning if it matches even once inside the provided username, the username contains a digit:
<pre><code class="hljs">// Regex to see if a digit is in the username, returns true if there is
const usernameIncludesDigit = /\d/.test(username.value); 

if (!usernameIncludesDigit) {
 incorrectInput += &#x27;Username must include at least one digit.\n&#x27;;
}
</code></pre>
<h3 id="passwordisbetween8and20characterslong">Password is Between 8 and 20 Characters Long</h3>
The <code>length</code> string attribute should give us the number of characters in the password. A simple conditional statement should do the trick:
<pre><code class="hljs">const badPasswordLength = (firstPassword.value.length &lt; 8 || firstPassword.value.length &gt; 20);

if (badPasswordLength) {
 incorrectInput += &#x27; The password should be within 8 to 20 characters.\n&#x27;;
}
</code></pre>
<h3 id="passwordcontainsatleastoneuppercasecharacter">Password Contains at Least One Uppercase Character</h3>
This is similar to what we did for username. We just need to modify the regular expression to check for uppercase letters instead of digits:
<pre><code class="hljs">// Regex to see if a digit is in the username, returns true if there is
const passwordIncludesUppercase = /[a-z]/.test(firstPassword.value); 

if (!passwordIncludesUppercase) {
 incorrectInput += &#x27; The password should contain at least one uppercase character.\n&#x27;;
} 
</code></pre>
<h3 id="verifythatthetwopasswordsarethesame">Verify that the Two Passwords are the Same</h3>
Finally, we need to compare <code>firstPassword</code> to <code>secondPassword</code> to see if they match:
<pre><code class="hljs">if (firstPassword.value !== secondPassword.value) {
 incorrectInput += &#x27;The passwords do not match.\n&#x27;;
}
</code></pre>
<h3 id="displayingtheerrormessages">Displaying the Error Messages</h3>
After all these checks, if any condition is unsatisfied, <code>incorrectInput</code> will not be an empty string and will contain the issue raised in that conditional block.
In this case, we will change the text in <code>errorDiv</code> to show our errors in red:
<pre><code class="hljs">if (incorrectInput !== &quot;&quot;) {
 // Change the error div tag to display the error message(s)
 errorDiv.innerText = incorrectInput; 
 // Change the color of the text to red
 errorDiv.style.color = &#x27;red&#x27;; 
 // Prevent the form button from submitting again, before fixing the issues
 error.preventDefault(); 
}
</code></pre>
<h3 id="testingthecode">Testing the Code</h3>
And now, let's test out our new form with the following input:
<ul>
<li>Username: <code>johndoe</code></li>
<li>Password: <code>42</code></li>
<li>Confirm Password: <code>421</code></li>
</ul>
Which should yield the following results:
<img src="https://stackabuse.s3.amazonaws.com/media/client-side-form-validation-using-vanilla-javascript-3+(2).jpg" alt="">
<h2 id="conclusion">Conclusion</h2>
In this article we used vanilla JavaScript to validate a simple HTML form.
JavaScript enabled us to define custom validation checks that fit our use case. For example, you can add custom patterns that a password must meet in order for a user to sign up on your website.

Osama Akhtar

In this tutorial, we'll go over how to validate form input in JavaScript, for a registration form. We'll use client-side form validation in vanilla JavaScript.