<h2 id="introduction">Introduction</h2>
Variables act as a container to store data. A developer can use type hints when creating variables or passing arguments, however, that's an optional feature in Python, and many codebases, old and new, are yet to have them. It's more common for a variable in Python to have no information of the type being stored.
If we had code that needed a dictionary but lacked type hints, how can we avoid errors if the variable used is not a dictionary?
In this tutorial, we'll take a look at how to check if a variable is a dictionary in Python, using the <code>type()</code> and <code>isinstance()</code> functions, as well as the <code>is</code> operator:
<ul>
<li><a href="#checkifvariableisadictionarywithtype">Check if Variable is Dictionary with type()</a></li>
<li><a href="#checkifvariableisadictionarywithisoperator">Check if Variable is Dictionary with is Operator</a></li>
<li><a href="#checkifvariableisadictionarywithisinstance">Check if Variable is Dictionary with isinstance()</a></li>
</ul>
Developers usually use <code>type()</code> and <code>is</code>, though, these can be limited in certain contexts, in which case, it's better to use the <code>isinstance()</code> function.
<h2 id="checkifvariableisadictionarywithtype">Check if Variable is a Dictionary with type()</h2>
We can use the <code>type()</code> function to instantly get the type of any variable. For a variable of type <code>Dictionary</code>, it must return <code>&lt;class 'dict'&gt;</code>:
<pre><code class="hljs">squares = {1: 1, 2: 4, 3: 9}
print(type(squares))
</code></pre>
This results in:
<pre><code class="hljs">&lt;class &#x27;dict&#x27;&gt;
</code></pre>
<h2 id="checkifvariableisadictionarywithisoperator">Check if Variable is a Dictionary with is Operator</h2>
In Python, <code>is</code> is an identity operator. It verifies if both the operands are identical to each other. Being identical indicates that they refer to the same memory location.
We can use the <code>is</code> operator with the result of a <code>type()</code> call with a variable and the <code>dict</code> class. It will output <code>True</code> only if the <code>type()</code> points to the same memory location as the <code>dict</code> class. Otherwise, it will output <code>False</code>.
As a sanity check, we can use the <code>id()</code> function to get the address of the object in memory and verify the comparison:
<pre><code class="hljs">squares = {1: 1, 2: 4, 3: 9}
print(type(squares) is dict) # True
print(&quot;memory address of type(squares):&quot;, id(type(squares)))
print(&quot;memory address of dict:&quot;, id(dict)) # Should have same ID as type(squares)
</code></pre>
This code will produce the following output on a Python interpreter:
<pre><code class="hljs">True
memory address of type(squares): 1609576584
memory address of dict: 1609576584
</code></pre>
Note: The memory address may vary for you, but the same ID should be present for both the <code>type(squares)</code> and <code>dict</code>.
One caveat of this method is that it fails to work if the variable is a type that's a subclass of <code>dict</code>. For example, the previous code would not work if the <code>squares</code> variable was an Ordered Dictionary instead:
<pre><code class="hljs">from collections import OrderedDict

squares = OrderedDict([(1, 1), (2, 4), (3, 9)])
print(type(squares) is dict) # False
print(&quot;memory address of type(squares):&quot;, id(type(squares)))
print(&quot;memory address of dict:&quot;, id(dict)) # Different ID as they&#x27;re different classes
</code></pre>
This outputs:
<pre><code class="hljs">False
memory address of type(squares): 9464512
memory address of dict: 9481952
</code></pre>
If your code is required to work on subclasses of Dictionaries, then you would prefer to use the <code>isinstance()</code> method.
<h2 id="checkifvariableisadictionarywithisinstance">Check if Variable is a Dictionary with isinstance()</h2>
As we have seen, the <code>is</code> operator will return <code>True</code> when the memory address of both the objects is the same. If we have a Dictionary of type inherited from class <code>dict</code>, it will return <code>False</code>. For example, a Dictionary of a subclass of <code>dict</code> like <code>OrderedDict</code> or <code>defaultdict</code> will not point to the same memory address as of <code>dict</code>.
Here we have the <code>isinstance()</code> function to the rescue. This function takes two arguments; an object and a class. If the object is an instance of the class or its subclasses, it will return <code>True</code>. If the object is not an instance of the given class, whether direct or indirect, it returns <code>False</code>.
Here is a code example to check if the variable is a Dictionary using the <code>isinstance()</code> function:
<pre><code class="hljs">from collections import OrderedDict

# Variable of type dict
squares = {1: 1, 2: 4, 3: 9}
print(isinstance(squares, dict)) # True

# Variable of type OrderedDict (Subclass of dict)
cubes = OrderedDict(((1, 1), (2, 8)))
print(isinstance(cubes, dict)) # True
</code></pre>
This code will produce the following output on a Python interpreter:
<pre><code class="hljs">True
True
</code></pre>
<h2 id="conclusion">Conclusion</h2>
This tutorial showed ways in which we can check if a variable is a Dictionary. We have first seen the <code>type()</code> function which outputs <code>&lt;class 'dict'&gt;</code> for any Dictionary object. Then we have seen the use of the <code>is</code> operator to check if the type of variable points to <code>dict</code> in the memory location. This returns <code>True</code> or <code>False</code> accordingly.
Lastly, we have seen that <code>is</code> fails at identifying inherited Dictionary objects. When we want to capture inherited objects, we can use the <code>isinstance()</code> function. It returns <code>True</code> if the object is directly or indirectly an instance of the given class (<code>dict</code> in this article), and <code>False</code> otherwise.
As both these methods return <code>True</code> or <code>False</code>, we can easily use them in conditional statements. Unless you explicitly want to reject subclasses of <code>dict</code>, the <code>isinstance()</code> function is the most reliable way to check if a variable is a Dictionary.

Marcus Sanatan

Naazneen Jatu

In Python, we can use these two ways to check if a given variable is a Dictionary: the type() function and the is operator; and the isinstance() function

Python: Check if Variable is a Dictionary

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll take a look at how to get the number of days between two dates in Python.
We'll be using the built-in <code>datetime</code> package, that allows you to really easily work with <code>datetime</code> objects in Python.
<h2 id="creatingadatetimeobject">Creating a Datetime Object</h2>
As datetime is a built-in module, you can access it right away by importing it at the top of your Python file.
You can construct <code>datetime</code> objects in a few different ways:
<pre><code class="hljs">from datetime import datetime

date_string = &quot;1 January, 2021&quot;

now = datetime.now() # Create Datetime based on system clock
dt1 = datetime(day=1, month=1, year=2021) # Create Datetime with given arguments
dt2 = datetime.strptime(date_string, &quot;%d %B, %Y&quot;) # Create Datetime from String
</code></pre>
There are certain rules to follow when it comes to <a target="_blank" href="/converting-strings-to-datetime-in-python/">Converting Strings to Datetime in Python</a>.
<h2 id="getnumberofdaysbetweendatesinpython">Get Number of Days Between Dates in Python</h2>
Trying to measure the numbers of days between dates without using the datetime module is a deceptively complex task - between accounting for leap years and the number of days in each month, trying to create your own implementation is nonsensical.
<blockquote>
With <code>datetime</code> however, it becomes trivial.
</blockquote>
You can simply subtract a <code>date</code> or <code>datetime</code> from each other, to get the number of days between them:
<pre><code class="hljs">from datetime import datetime

date1 = datetime.now()
date2 = datetime(day=1, month=7, year=2021)

timedelta = date2 - date1
print(timedelta)
</code></pre>
This returns a <code>timedelta</code> object, which contains <code>days</code>, <code>seconds</code> and <code>microseconds</code> and represents the duration between any two <code>date</code>/<code>time</code> or <code>datetime</code> objects.
Printing this object will return the days, hours, minutes, seconds and microseconds to that event:
<pre><code class="hljs">149 days, 5:22:52.255124
</code></pre>
If you're not interested in some of these metrics, you can specify which of them you'd like to access with <code>timedelta.days</code>, <code>timedelta.seconds</code> and <code>timedelta.microseconds</code>:
<pre><code class="hljs">now = datetime.now()
new_years = datetime(day=1, month=1, year=2022)
countdown = new_years - now

print(&#x27;Today is: &#x27;, now)
print(&#x27;New Year is on: &#x27;, new_years)
print(&#x27;Days until New Years: &#x27;, countdown.days)
</code></pre>
Here, we've assigned the days between <code>now</code> and <code>new_years</code> into <code>countdown</code>, which is a <code>timedelta</code> object.
Then, we can simply access the <code>days</code> parameter of that object to get the number of days between them. This results in:
<pre><code class="hljs">Today is: 2021-02-01 18:35:12.272524
New Year is on: 2022-01-01 00:00:00
Days until New Years: 333
</code></pre>
<h2 id="addingandsubtractingdaysusingtimedelta">Adding and Subtracting Days Using TimeDelta</h2>
What if instead of trying to subtract two known dates from each other, you wanted to add or subtract a time-frame? For example, a customer subscribed to your service for a monthly fee. You'll want to remind them to renew it after 30 days.
You can construct a time-frame for those 30 days, using <code>timedelta</code> and add or subtract that from any other <code>datetime</code> object:
<pre><code class="hljs">from datetime import datetime, timedelta

now = datetime.now()
thirty_days = timedelta(days=30)

print(&#x27;In 30 days: &#x27;, now + thirty_days)
print(&#x27;30 days ago: &#x27;, now - thirty_days)
</code></pre>
This results in:
<pre><code class="hljs">In 30 days: 2021-03-03 18:41:49.922082
30 days ago: 2021-01-02 18:41:49.922082
</code></pre>
This is an incredibly useful feature when trying to implement scheduling, or retrieving database entries based on a moving window (such as the trailing 30 days).
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've covered everything you need to know about getting the number of days between two dates in Python.
We've worked with <code>datetime</code> objects and <code>timedelta</code> to achieve this functionality.

Spencer Porter

In this tutorial, we'll go over how to get the number of days between two dates in Python, using the datetime module and timedelta objects, as well as add and subtract fixed timeframes.

Python: Get Number of Days Between Dates

<h2 id="introduction">Introduction</h2>
In this article, we'll take a look at how to remove keys from Python dictionaries. This can be done with the <code>pop()</code> function, the <code>del</code> keyword, and with dict comprehensions.
<h2 id="removeakeyusingpopkeyd">Remove a Key Using pop(key,d)</h2>
The <code>pop(key, d)</code> function removes a key from a dictionary and returns its value. It takes two arguments, the key is removed and the optional value to return if the key isn't found. Here's an example of popping an element with only the required <code>key</code> argument:
<pre><code class="hljs">my_dict = {1: &quot;a&quot;, 2: &quot;b&quot;}
popped_value = my_dict.pop(1)

line = &quot;The value removed from the dictionary of the key: 1 is {}&quot;
print(line.format(popped_value))
</code></pre>
This snippet returns the following output:
<pre><code class="hljs">The value removed from the dictionary of the key: 1 is a
</code></pre>
Now, observe what happens when we try to remove a key that doesn't exist:
<pre><code class="hljs">my_dict = {1: &quot;a&quot;, 2: &quot;b&quot;}
popped_value = my_dict.pop(3)

line = &quot;The value removed from the dictionary of the key: 3 is {}&quot;
print(line.format(popped_value))
</code></pre>
This raises a KeyError, as expected since it doesn't exist:
<pre><code class="hljs">Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
KeyError: 3
</code></pre>
If you call <code>pop()</code> on a key that doesn't exist, Python would return a <code>KeyError</code>. So only use <code>pop(key)</code> if you're confident that the key exists in the dictionary.
If you are unsure if the key exists then put a value for the second, optional argument for <code>pop()</code> - the default value. Instead of throwing a KeyError it will return that value.
The above snippet can be rewritten as:
<pre><code class="hljs">my_dict = {1: &quot;a&quot;, 2: &quot;b&quot;}
removed_value = my_dict.pop(3, None)

line = &quot;The value removed from the dictionary of the key: 3 is {}&quot;
print(line.format(removed_value))
</code></pre>
And now it doesn't throw an error when we run it:
<pre><code class="hljs">The value removed from the dictionary of the key: 3 is None
</code></pre>
<h2 id="removeakeyusingdeldictkey">Remove a Key Using del dict[key]</h2>
Another way to remove a key from a dictionary is through the <code>del</code> keyword. This keyword can remove any object. It can also delete a key-value pair of a dictionary like this: <code>del dict_name[key]</code>:
<pre><code class="hljs">my_dict = {1: &quot;a&quot;, 2: &quot;b&quot;}
del my_dict[1]

line = &quot;The dictionary after deletion is {}&quot;
print(line.format(my_dict))
</code></pre>
The above snippet returns the following output, denoting the dictionary with just the left out value(s):
<pre><code class="hljs">The dictionary after deletion is {2: &#x27;b&#x27;}
</code></pre>
Unlike <code>pop()</code>, no value is returned when deleted. If you are looking to preserve the existing dictionary input, you can find the next section to be useful.
<h2 id="removemultipledictionarykeyswithdictcomprehensions">Remove Multiple Dictionary Keys with Dict Comprehensions</h2>
The previous methods update a dictionary in-place, meaning that the key-value pair is destroyed. If the original key needs to be preserved, we can use a custom function to do so. In Python, it's commonly known that we can use list comprehensions to create a new list based on an existing one. We can do the same with dictionaries using dict comprehensions.
So instead of deleting values in a list, we can use a dict comprehension to create a new dictionary with a condition that excludes the values we don't want.
Take the following example where we create a new dictionary that doesn't have a key of <code>1</code>:
<pre><code class="hljs">my_dict = {1: &quot;a&quot;, 2: &quot;b&quot;}
my_dict2 = {k: v for k, v in my_dict.items() if k != 1}

line = &quot;The new dictionary is {}&quot;
print(line.format(my_dict2))
</code></pre>
This snippet generates the following output, printing the new dictionary:
<pre><code class="hljs">The new dictionary is {2: &#x27;b&#x27;}
</code></pre>
Note that we're creating a new dictionary, adding to our program's memory usage. For dictionaries of bigger sizes, if we don't exclude a lot of members then we're nearly doubling the memory used for that data.
<h2 id="benchmarkingfunctionefficiency">Benchmarking Function Efficiency</h2>
We have observed three methods so far. But which method is the fastest among the three?
Let's create a random dictionary on which we will be testing out our methods. The following function <code>gen_random_dict(n)</code> takes a list as an argument and creates a dictionary with random seeded integers:
<pre><code class="hljs">import random

def gen_random_dict(n):
 random.seed(0)
 mydict = {}
 for i in range(n):
 nmbr = random.randrange(1, n, 1)
 mydict[nmbr] = &quot;value &quot;+ str(nmbr)
 return mydict
</code></pre>
In this same file, let's add some functions that delete a key in each of the ways we discussed:
<pre><code class="hljs"># Remove a key using pop function
def remove_using_pop(dict_input):
 dict_input.pop(1)
 return None


# Remove a key using del keyword
def remove_using_del(dict_input):
 del dict_input[1]
 return None


# Remove a key using condition
def remove_using_condition(dict_input):
 return {k: v for k, v in dict_input.items() if k != 1}
</code></pre>
Finally, add the following code that uses the <code>timeit</code> module that measures the execution time of our code:
<pre><code class="hljs">import timeit


if __name__ == &quot;__main__&quot;:
 func_to_be_tested = &quot;remove_using_pop(gen_random_dict(10000))&quot;
 setup_stmt = &quot;from __main__ import remove_using_pop, gen_random_dict&quot;
 runtime1 = timeit.timeit(func_to_be_tested, setup=setup_stmt, number=1)
 func_to_be_tested = &quot;remove_using_del(gen_random_dict(10000))&quot;
 setup_stmt = &quot;from __main__ import remove_using_del, gen_random_dict&quot;
 runtime2 = timeit.timeit(func_to_be_tested, setup=setup_stmt, number=1)
 func_to_be_tested = &quot;remove_using_condition(gen_random_dict(10000))&quot;
 setup_stmt = &quot;from __main__ import remove_using_condition, gen_random_dict&quot;
 runtime3 = timeit.timeit(func_to_be_tested, setup=setup_stmt, number=1)
 print(&quot;Runtime for removing key from Dict:&quot;)
 print(&quot;\t1) Using Pop: {}&quot;.format(str(runtime1)))
 print(&quot;\t2) Using Del: {}&quot;.format(str(runtime2)))
 print(&quot;\t3) Using Condition: {}&quot;.format(str(runtime3)))
</code></pre>
While results may vary on your computer, the pattern should be consistent. Here's the output we got after executing this script:
<pre><code class="hljs">Runtime for removing key from Dict:
 1) Using Pop: 0.015606499999194057
 2) Using Del: 0.01090950000070734
 3) Using Condition: 0.011443700001109391
</code></pre>
Using the <code>del</code> keyword has an edge over the rest of the methods. Although the time difference doesn't seem to be very dramatic on smaller dictionaries. Though, it will make a huge impact when the size of the dictionary is large.
<h2 id="conclusion">Conclusion</h2>
In this article, we learned three ways by which a key-value pair can be removed from a dictionary - <code>pop()</code>, <code>del</code>, and dict comprehensions. Choosing the right method for the right size of dictionary can help in decreasing the runtime of the script and the memory usage.

Sathiya Sarathi Gunasekaran

Let's learn three ways to remove key-value pairs from a Python dictionary - the `pop()` function, the `del` keyword, and dict comprehensions.


Python: How to Remove a Key from a Dictionary

<h2 id="introduction">Introduction</h2>
A dictionary in Python is a collection of items that store data as key-value pairs. We can access and manipulate dictionary items based on their key. Dictionaries are mutable and allow us to add new items to them.
The quickest way to add a single item to a dictionary is by using a dictionary's index with a new key and assigning a value. For example, we add a new key-value pair like this:
<pre><code class="hljs">snacks[&#x27;chocolate&#x27;] = 5
</code></pre>
Python allows adding multiple items to dictionaries as well. In this tutorial, we'll take a look at how to add keys to a dictionary in Python.
<h2 id="addkeytoapythondictionary">Add Key to a Python Dictionary</h2>
There are multiple ways to add a new key-value pair to an existing dictionary. Let's have a look at a few common ways to do so.
<h3 id="addkeywithvalue">Add Key with Value</h3>
We can add a new key to a dictionary by assigning a value to it. If the key is already present, it overwrites the value it points to. The key has to be written in subscript notation to the dictionary like this:
<pre><code class="hljs">my_dictionary[new_key] = new_value
</code></pre>
This key-value pair will be added to the dictionary. If you're using Python 3.6 or later, it will be added as the last item of the dictionary.
Let's make a dictionary, and then add a new key-value pair with this approach:
<pre><code class="hljs">squares = {1: 1, 2: 4, 3: 9}
squares[4] = 16 # Adding new key-value pair
print(squares)
</code></pre>
This will result in:
<pre><code class="hljs">{1: 1, 2: 4, 3: 9, 4: 16}
</code></pre>
<h3 id="addkeytodictionarywithoutvalue">Add Key to Dictionary without Value</h3>
If you'd just like to add a key, without a value, you can simply put <code>None</code> instead of the value, with any of the methods covered in this article:
<pre><code class="hljs">squares = {1: 1, 2: 4, 3: 9}
squares[&#x27;x&#x27;] = None # Adding new key without value
print(squares)
</code></pre>
This results in:
<pre><code class="hljs">{1: 1, 2: 4, 3: 9, &#x27;x&#x27;: None}
</code></pre>
<h3 id="addmultiplekeyvaluepairswithupdate">Add Multiple Key-Value Pairs with update()</h3>
In Python, we can add multiple key-value pairs to an existing dictionary. This is achieved by using the <code>update()</code> method. This method takes an argument of type <code>dict</code> or any iterable that has the length of two - like <code>((key1, value1),)</code>, and updates the dictionary with new key-value pairs.
If the key is already present in the dictionary, it gets overwritten with the new value.
The keys can also be passed as keyword arguments to this method with their corresponding values, like <code>dictionary.update(new_key=new_value)</code>.

 <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: This is arguably the most popular method of adding new keys and values to a dictionary.

 </div>
 </div>
 </div>
 Let's use the <code>update()</code> method to add multiple key-value pairs to a dictionary:
<pre><code class="hljs">rainbow = {&#x27;red&#x27;: 1}

# Update by passing dictionary 
new_key_values_dict = {&#x27;orange&#x27;: 2, &#x27;yellow&#x27;: 3}
rainbow.update(new_key_values_dict)
print(&quot;update by passing dictionary&quot;)
print(rainbow)

# Update by passing iterables
new_key_values_itr = ((&#x27;green&#x27;,4), (&#x27;blue&#x27;,5))
rainbow.update(new_key_values_itr)
print(&quot;update by passing iterables&quot;)
print(rainbow)

# Update using keyword arguments
rainbow.update(indigo=6, violet=7)
print(&quot;update using keyword arguments&quot;)
print(rainbow)
</code></pre>
Running this code will produce the following output:
<pre><code class="hljs">update by passing dictionary
{&#x27;red&#x27;: 1, &#x27;orange&#x27;: 2, &#x27;yellow&#x27;: 3}
update by passing iterables
{&#x27;red&#x27;: 1, &#x27;orange&#x27;: 2, &#x27;yellow&#x27;: 3, &#x27;green&#x27;: 4, &#x27;blue&#x27;: 5}
update using keyword arguments
{&#x27;red&#x27;: 1, &#x27;orange&#x27;: 2, &#x27;yellow&#x27;: 3, &#x27;green&#x27;: 4, &#x27;blue&#x27;: 5, &#x27;indigo&#x27;: 6, &#x27;violet&#x27;: 7}
</code></pre>
<h3 id="usingmergeoperatorpython39">Using Merge Operator (Python 3.9+)</h3>
From Python version 3.9, Merge (<code>|</code>) and Update (<code>|=</code>) operators have been added to the built-in <code>dict</code> class.
These are very convenient methods to add multiple key-value pairs to a dictionary. The Merge (<code>|</code>) operator creates a new dictionary with the keys and values of both of the given dictionaries. We can then assign this result to a new dictionary.
Whereas the Update (<code>|=</code>) operator, adds the key-value pairs of the second dictionary into the first dictionary. So, the existing dictionary gets updated with multiple key-value pairs from another dictionary.
Here's an example of using Merge (<code>|</code>) and Update (<code>|=</code>) operators to add new keys to a dictionary:
<pre><code class="hljs">colors_set1 = {‘red’: 1, &#x27;orange’: 2, &#x27;yellow&#x27;: 3}
colors_set2 = {&#x27;green&#x27;: 4, &#x27;blue&#x27;: 5, &#x27;indigo&#x27;: 6, &#x27;violet&#x27;: 7}

# Merge operator
rainbow = colors_set1 | colors_set2
print(&quot;using merge:&quot;, rainbow)

# Update operator
colors_set1 |= colors_set2
print(&quot;using update:&quot;, colors_set1)
</code></pre>
This code will produce the following output on the Python(3.9+) interpreter:
<pre><code class="hljs">using merge: {&#x27;red&#x27;: 1, &#x27;orange&#x27;: 2, &#x27;yellow&#x27;: 3, &#x27;green&#x27;: 4, &#x27;blue&#x27;: 5, &#x27;indigo&#x27;: 6, &#x27;violet&#x27;: 7}
using update: {&#x27;red&#x27;: 1, &#x27;orange&#x27;: 2, &#x27;yellow&#x27;: 3, &#x27;green&#x27;: 4, &#x27;blue&#x27;: 5, &#x27;indigo&#x27;: 6, &#x27;violet&#x27;: 7}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we learned how we can add a new key to a dictionary. We first added the key-value pair using subscript notation - we added a key to a dictionary by assigning a value to it. We then looked at the <code>update()</code> method to add multiple key-value pairs to a dictionary. We've also used the <code>update()</code> method with parameters of type dictionary, tuple, and keyword arguments. Lastly, we probed into the Merge and Update operators available from Python versions 3.9 onwards.
The <code>update()</code> method of dictionary proves to be the most popular way to add new keys to an existing dictionary.

Let's add new keys to a Python dictionary. We'll add a single key, and multiple keys with the update() function, merge operator | and update operator |= 

Python: How to Add Keys to Dictionary

Python: How to Add Keys to a Dictionary

<h2 id="introduction">Introduction</h2>
Form Data Validation is a very common, and rudimentary step in building any web application with user input. We want to make sure that certain ranges are respected, and that certain formats are followed. For example, we'll want to make sure that the user isn't <code>-345</code> years old, or that their email address is valid.
There are many ways to validate form data - and the method you use depends on your application. In general, you'll want to perform <a target="_blank" href="client-side-form-validation-using-vanilla-javascript">client-side validation</a>, as well as server-side validation. Client-side validation makes sure that unfiltered data doesn't even reach the back-end, while server-side validation makes sure that the wrong data isn't processed further.
In this article, we'll cover how to perform form data validation in Spring Boot with Thymeleaf, as the template engine.
We'll leverage Spring Boot's built-in <a rel="nofollow noopener" target="_blank" href="https://beanvalidation.org/">Bean Validation API</a>, which makes this process simple and straightforward.
<h2 id="springbootvalidationmavendependency">Spring Boot Validation Maven Dependency</h2>
Spring Boot allows us to define validation criteria using annotations. In your Domain Model, you can simply annotate fields with the constraints, and it'll enforce them.
For the validation annotations to work we need to add the following dependency:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
 &lt;artifactId&gt;spring-boot-starter-validation&lt;/artifactId&gt;
&lt;/dependency&gt;
</code></pre>
<h2 id="domainmodel">Domain Model</h2>
Let's define a simple POJO, with a few fields that we want to validate:
<pre><code class="hljs">@Entity
public class Person {

 @Id
 @GeneratedValue(strategy= GenerationType.AUTO)
 private Long id;

 @NotEmpty
 @Size(min = 5)
 private String fullName;

 @NotEmpty
 @Email
 private String email;

 @NotNull
 @Min(value = 18)
 private Integer age;

 // Getters and Setters

}
</code></pre>
Now, let's break the annotations we used:
<ul>
<li><code>@NotEmpty</code> - is used to constrain a field of type <code>String</code>, <code>Collection</code>, <code>Map</code>, or <code>Array</code> to not be <code>null</code> or empty.</li>
<li><code>@Size([min = x, max = y])</code> - is used to define the rules for the size of a <code>String</code>, <code>Collection</code>, <code>Map</code>, or <code>Array</code>.</li>
<li><code>@Email</code> - helps us to validate the string against a regex which defines the structure of a valid email.</li>
<li><code>@NotNull</code> - tells Spring the field should not be null, but it can be empty.</li>
<li><code>@Min</code> and <code>@Max</code> are used to specify the limits of a variable. For example, the <code>@Min</code> age could be set to, say, 18.</li>
</ul>
<h2 id="persistencelayerrepository">Persistence Layer - Repository</h2>
To create a simple CRUD repository, all we have to do is extend the <code>JpaRepository</code> and supply our domain model and the ID's data type:
<pre><code class="hljs">@Repository
public interface PersonRepository extends JpaRepository&lt;Person, Long&gt; {
}
</code></pre>
<h2 id="creatingaformwiththymeleaf">Creating a Form with Thymeleaf</h2>
Now, let's make a simple form using HTML and Bootstrap to collect information:
<pre><code class="hljs">&lt;form th:action=&quot;@{/add}&quot; th:object=&quot;${person}&quot; method=&quot;post&quot; class=&quot;form&quot;&gt;
 &lt;div class=&quot;form-group&quot;&gt;
 &lt;label for=&quot;fullName&quot;&gt;Name&lt;/label&gt;
 &lt;input class=&quot;form-control&quot; type=&quot;text&quot; th:field=&quot;*{fullName}&quot; id=&quot;fullName&quot; placeholder=&quot;Full Name&quot;&gt;
 &lt;div class=&quot;alert alert-warning&quot; th:if=&quot;${#fields.hasErrors(&#x27;fullName&#x27;)}&quot; th:errors=&quot;*{fullName}&quot;&gt;&lt;/div&gt;
 &lt;/div&gt;
 &lt;div class=&quot;form-group&quot;&gt;
 &lt;label for=&quot;email&quot;&gt;Email&lt;/label&gt;
 &lt;input class=&quot;form-control&quot; type=&quot;text&quot; th:field=&quot;*{email}&quot; id=&quot;email&quot; placeholder=&quot;Email&quot;&gt;
 &lt;div class=&quot;alert alert-warning&quot; th:if=&quot;${#fields.hasErrors(&#x27;email&#x27;)}&quot; th:errors=&quot;*{email}&quot;&gt;&lt;/div&gt;
 &lt;/div&gt;
 &lt;div class=&quot;form-group&quot;&gt;
 &lt;label for=&quot;age&quot;&gt;Age&lt;/label&gt;
 &lt;input class=&quot;form-control&quot; type=&quot;text&quot; th:field=&quot;*{age}&quot; id=&quot;age&quot; placeholder=&quot;Age&quot;&gt;
 &lt;div class=&quot;alert alert-warning&quot; th:if=&quot;${#fields.hasErrors(&#x27;age&#x27;)}&quot; th:errors=&quot;*{age}&quot;&gt;&lt;/div&gt;
 &lt;/div&gt;
 &lt;input type=&quot;submit&quot; class=&quot;btn btn-success&quot; value=&quot;Add User&quot;&gt;
&lt;/form&gt;
</code></pre>
The form points to <code>/add</code> and sends a <code>POST</code> request. The fields in our object, <code>fullName</code>, <code>age</code> and <code>email</code> are in the form, signified by <code>th:field</code>. Since we've got our <code>th:object=${person}</code>,we can refer to this <code>person</code> object by substituting it with a <code>*</code> before the fields.
<code>*{fullName}</code> is the same as <code>${person.fullName}</code>. Each input also has a hidden <code>&lt;div&gt;</code> which is shown only if the <code>${#fields.hasErrors()}</code> calls evaluate to <code>true</code>. If there aren't errors, this div doesn't exist. If there are, the <code>th:errors</code> tag lets us specify a message. If we simply pass in the field that causes the error, such as <code>th:errors=&quot;*{age}&quot;</code>, the default message from the Bean Validator API are used, for that field.
This results in a form that looks like this:
<img src="https://stackabuse.s3.amazonaws.com/media/spring-boot-thymeleaf-form-data-validation-with-bean-validator-1.png" alt="basic html form">
Since these messages aren't very user-friendly, we'll want to customize them by supplying our own messages.
<h2 id="controller">Controller</h2>
Now, let's make a controller that'll handle a request to save a <code>Person</code> into the database. As usual, we'll have a <code>@GetMapping()</code> to show the form, and a <code>@PostMapping</code> to handle the request. In the method signature of the <code>@PostMapping</code>, we'll annotate the POJO with <code>@Valid</code>.
The <code>@Valid</code> annotation triggers the Bean Validator to check if the fields populated in the object conform to the annotations we've used in the class definition. If you don't use the <code>@Valid</code> annotation, it won't check anything, and even values you might not expect can be populated in the object.
In our case, the <code>Person person</code> object is the object that's populated with the inputs of a form:
<pre><code class="hljs">@GetMapping(&quot;/add&quot;)
public String showAddPersonForm(Person person) {
 return &quot;add-person&quot;;
}

@PostMapping(&quot;/add&quot;)
public String addPerson(@Valid Person person, BindingResult result, Model model) {
 if (result.hasErrors()) {
 return &quot;add-person&quot;;
 }
 repository.save(person);
 return &quot;redirect:/index&quot;;
}
</code></pre>
If there are any issues with this <code>Person</code>, the <code>${fields}</code> attribute will have errors within it, tied to the field that caused the error.
<h2 id="customizingerrormessages">Customizing Error Messages</h2>
To set a custom message for any validation constraint, you can use the <code>message</code> option:
<pre><code class="hljs">@NotEmpty(message = &quot;Field can&#x27;t be empty!)
private String field;
</code></pre>
You can simply write these messages out in your model, like this. Though, it's considered good practice to put the validation messages in a <code>properties</code> file, that you can reference. This is done since you can bundle all validation messages together, and can update them if the models get changed at a later date.
Let's make our <code>ValidationMessages.properties</code> under <code>src/main/resources</code>:
<pre><code class="hljs">Size.Person.FullName=The Full Name should have at least 5 characters
</code></pre>
We will then modify the <code>Person</code> model, and supply this property as the <code>message</code> of the <code>@Size</code> annotation:
<pre><code class="hljs">@NotEmpty(message = &quot;The Full Name can&#x27;t be null&quot;)
@Size(min = 5, message = &quot;{Size.Person.FullName}&quot;)
private String fullName;
</code></pre>
Let's go back to our form and see how it looks now:
<img src="https://stackabuse.s3.amazonaws.com/media/spring-boot-thymeleaf-form-data-validation-with-bean-validator-2.png" alt="customized error messages spring boot bean validator">
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over how to use the Bean Validator API that Spring Boot uses to effortlessly perform form data validation with Thymeleaf.
We've created a domain model, annotated our fields with Bean Validator constraints. Then, we've made a repository and controller to display the form and process it, as well as save the relevant information into a <code>Person</code> object, making sure that the fields are validated with the <code>@Valid</code> annotation.
You can find the source code <a rel="nofollow noopener" target="_blank" href="https://github.com/alexchirea/SimpleSpringBootApp/tree/SpringValidationFormThymeleaf">on GitHub</a>.

Alex Chirea

In this tutorial, we'll cover how to perform Spring Boot Thymeleaf Form Data Validation using the well-known Bean Validator library.

Spring Boot Thymeleaf Form Data Validation with Bean Validator

<h2 id="introduction">Introduction</h2>
Printing an array is a quick way to give us visibility on the values of the contents inside. Sometimes the array values are the desired output of the program.
In this article, we'll take a look at how to print an array in Java using four different ways.
While the &quot;best way&quot; depends on what your program needs to do, we begin with the simplest method for printing and then show more verbose ways to do it.
<ul>
<li><a href="#printanarrayusingarraystostringandarraysdeeptostring">Print an Array Using Arrays.toString() and Arrays.deepToString()</a></li>
<li><a href="#printanarrayusingjava8streams">Print an Array Using Java 8 Streams</a></li>
<li><a href="#printanarraybyconvertingtolist">Print an Array by Converting to List</a></li>
<li><a href="#printanarrayusingforloops">Print an Array Using For Loops</a></li>
<li><a href="#convertingtolistandusinganiterator">Converting To List and Using an Iterator</a></li>
</ul>
<h2 id="printanarrayusingarraystostringandarraysdeeptostring">Print an Array Using Arrays.toString() and Arrays.deepToString()</h2>
The built-in <code>toString()</code> method is an extremely simple way to print out formatted versions of objects in Java.
Every data type in Java is considered a class and by default, every class inherits from <code>java.lang.Object</code>, the root of Java's class hierarchy. That's why every class has a <code>toString()</code> method. However, arrays don't override the <code>toString()</code> method to format the output nicely, and it just returns the inherited value, which is the hash of the object.
We print arrays using the <code>toString()</code> method from the class in <code>java.util.Arrays</code>.
Take this example where we print the values of an array of integers:
<pre><code class="hljs">int[] intSequence = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

System.out.println(Arrays.toString(intSequence));
</code></pre>
The code above will output the following:
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
</code></pre>
Note how all the elements are comma-separated and in square brackets. This method is like a visual representation of the array.
We can use this method to print arrays of different types as well:
<pre><code class="hljs">double[] doubleValues = {5.5, 2.37, 9.9, 1.02};
System.out.println(Arrays.toString(doubleValues));

String[] stringValues = {&quot;alabama&quot;, &quot;arkansas&quot;, &quot;kentucky&quot;};
System.out.println(Arrays.toString(stringValues));
</code></pre>
These respectively result in:
<pre><code class="hljs">[5.5, 2.37, 9.9, 1.02]
[alabama, arkansas, kentucky]
</code></pre>
The <code>toString()</code> method is only effective for one-dimensional arrays. When we have nested arrays we need use the <code>deepToString()</code> method:
<pre><code class="hljs">double[][] coordinates = {{40.50, 50.75}, {22.25, 32.75}};
System.out.println(Arrays.deepToString(coordinates));

String[][] songLines = {{&quot;Take your nose off my keyboard&quot;}, {&quot;What you bothering me for?&quot;}};
System.out.println(Arrays.deepToString(songLines));
</code></pre>
These result in:
<pre><code class="hljs">[[40.5, 50.75], [22.25, 32.75]]
[[Take your nose off my keyboard], [What you bothering me for?]]
</code></pre>
If you need a visual of what's in your array at a glance, the <code>toString()</code> and <code>deepToString()</code> methods are your best option.
However, these methods don't allow you to format your output. This approach is basically just a workaround for the fact that arrays don't override the <code>toString()</code> method by default.
If you'd prefer some flexibility with the formatting, you might consider using Java 8 Streams.
<h2 id="printanarrayusingjava8streams">Print an Array Using Java 8 Streams</h2>
One option for printing an array is to convert it to a stream of objects, then print each element in the stream. We have a few options to leverage streams to print our array.
For example, we can print our array line by line like this:
<pre><code class="hljs">String[] languages = {&quot;Java&quot;, &quot;Python&quot;, &quot;JavaScript&quot;};
Arrays.stream(languages).forEach(System.out::println);
</code></pre>
In this case, we use the static <code>stream()</code> method of the <code>Arrays</code> class to create a sequential stream of our data. For each element in our stream, we call the <code>println()</code> function on it, making it appear line by line like this:
<pre><code class="hljs">Java
Python
JavaScript
</code></pre>
Note: We reference the <code>println()</code> function like this: <code>System.out::println</code>. The <code>::</code> in Java is a method reference operator. The <code>forEach()</code> function can either use a <a href="/lambda-expressions-in-java/" target="_blank">lambda function</a> or a <a href="/method-references-in-java-8/" target="_blank">method reference</a>.
Alternatively, we can use the <code>Stream</code> class from <code>java.util.stream.Stream</code> to similarly call the <code>println()</code> function on a stream of our array data. We can construct a Stream of this data using <code>Stream.of()</code>:
<pre><code class="hljs">String[] languages = {&quot;Java&quot;, &quot;Python&quot;, &quot;JavaScript&quot;};
Stream.of(languages).forEach(System.out::println);
</code></pre>
With this code we'll get the same output:
<pre><code class="hljs">Java
Python
JavaScript
</code></pre>
Let's try this out with nested arrays as well, adding the release dates of the initial versions of these languages:
<pre><code class="hljs">String[][] languages = {{&quot;Java&quot;, &quot;1996&quot;}, {&quot;Python&quot;, &quot;1994&quot;}, {&quot;JavaScript&quot;, &quot;1995&quot;}};

Arrays.stream(languages).forEach(System.out::println);
// OR
Stream.of(languages).forEach(System.out::println);
</code></pre>
The output for each print via streams would look something like this:
<pre><code class="hljs">[Ljava.lang.String;@e9e54c2
[Ljava.lang.String;@65ab7765
[Ljava.lang.String;@1b28cdfa
</code></pre>
That doesn't work very well... We're calling <code>println()</code> on array objects again. We'll have to stream those objects again, and print their elements.
To print nested arrays, we can use a lambda expression in the <code>forEach()</code> function that can go to the second level, by making another stream of each level, and printing the entries out that way:
<pre><code class="hljs">String[][] languages = {{&quot;Java&quot;, &quot;1996&quot;}, {&quot;Python&quot;, &quot;1994&quot;}, {&quot;JavaScript&quot;, &quot;1995&quot;}};

Arrays.stream(languages).forEach(s -&gt; Arrays.stream(s).forEach(System.out::println)); 
// OR
Stream.of(languages).forEach(s -&gt; Arrays.stream(s).forEach(System.out::println));
</code></pre>
This lambda function prints the elements in each nested array. When compiled and executed, we would get this output:
<pre><code class="hljs">Java
1996
Python
1994
JavaScript
1995
</code></pre>
Streams make working with collections a breeze. But Java is flexible to provide even more ways. The traditional for-loop does a lot for us still. Let's have a look at printing an array with loops.
<h2 id="printanarraybyconvertingtolist">Print an Array by Converting to List</h2>
You can easily convert a Java array into a <code>List</code> implementation. There are various ways to do that, and we've covered each in detail in our <a target="_blank" href="/how-to-convert-a-java-array-to-arraylist">How to Convert a Java Array to ArrayList</a> article.
In short, calling <code>toString()</code>, or just printing out (which implicitly calls <code>toString()</code>) on a <code>List</code> implementation, will print out the contents:
<pre><code class="hljs">Integer[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
List&lt;Integer&gt; numberList = Arrays.asList(numbers);

System.out.println(numberList);
</code></pre>
This results in:
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
</code></pre>
Additionally, you can use <code>.forEach()</code> natively on any <code>Collection</code>, which a <code>List</code> is. So, you can just go ahead and do this as well:
<pre><code class="hljs">Integer[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
Arrays.asList(numbers).forEach(System.out::println);
</code></pre>
Though, this isn't a nicely formatted option:
<pre><code class="hljs">12345678910
</code></pre>
You can ditch the method reference and just use a lambda for more control:
<pre><code class="hljs">Integer[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
Arrays.asList(numbers)
 .forEach(number -&gt; System.out.print(String.format(&quot;%d, &quot;, number)));
</code></pre>
This results in:
<pre><code class="hljs">1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 
</code></pre>
<h2 id="printanarrayusingforloops">Print an Array Using For Loops</h2>
A more well-known approach to printing an array in Java is to use a <code>for</code> loop. With a <code>for</code> loop we get the index of the element, and we can use the index to get the element of an array.
We set up a <code>for</code> loop with a variable, commonly named <code>i</code>, as the counter starting from element <code>0</code>. This is then followed by the condition that compares <code>i</code> to the number of elements in the array.
Note: The number of elements in the array that will be used in the loop's condition should never be hardcoded. Java provides an attribute called <code>length</code> that allows the programmer to dynamically calculate the number of elements in an array.
Last but not least, our <code>for</code> loop takes the incremental value. In our case we will use the <code>i++</code> notation to keep increasing our counter by one element in each iteration.
Once our loop is all set and ready, we will simply use the <code>System.out.println()</code> statement to display each element in the array using the rectangular bracket notation <code>[i]</code> taking as input our counter <code>i</code>.
Here's an example where we print all the elements of an integer array line by line:
<pre><code class="hljs">int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

for (int i = 0; i &lt; numbers.length; i++){
 System.out.println(numbers[i]);
}
</code></pre>
Executing this code would print the following in your console:
<pre><code class="hljs">1
2
3
4
5
6
7
8
9
10
</code></pre>
There isn't much more to using <code>for</code> loops. They're quite flexible and conceptually simple. For example, if you had nested arrays then you'll use nested <code>for</code> loops.
Finally, let's have a look at iterators and lists.
<h2 id="convertingtolistandusinganiterator">Converting To List and Using an Iterator</h2>
A Java iterator object allows us to display each element of our array without having to use the index approach we covered in the <code>for</code> loop section.
To use iterators, we have to change the datatype of the array to a <code>List</code>. We can do this by using the <code>Array.asList()</code> method and save the list values returned in a new variable. The <code>asList()</code> method takes in the array, and turns it into a <code>List</code> implementation.
Next, you will need an iterator object to set up your array iterator. An iterator is like a pointer that points to every element in the array. The iterator helps you to inspect each element in a singular manner.
To create an iterator object, we will use the <code>iterator()</code> method of our <code>List</code>. Once our iterator object was created we’ll use the <code>while</code> loop as it offers a more compact way of printing each element returned by the iterator.
The <code>while</code> loop's condition will contain a call to the <code>hasNext()</code> method of our iterator. Inside the <code>while</code> loop, we print each element by calling <code>System.out.println()</code>. We get elements from the iterator by calling the <code>next()</code> method. The <code>while</code> loop will keep iterating over each element until we have traversed our array (via the <code>List</code>).
Here's an example where we take an array of integers and print each element line by line by using an iterator:
<pre><code class="hljs">Integer[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
List&lt;Integer&gt; numberList = Arrays.asList(numbers);
Iterator&lt;Integer&gt; numberIterator = numberList.iterator();

while(numberIterator.hasNext()) {
 System.out.println(numberIterator.next());
}
</code></pre>
Compared to the for loops, this method is preferred by developers who rather not deal with array indices. You are guaranteed the upcoming element with <code>next()</code>. Iterators are powerful because we use this same flow for any type of <code>List</code> like an <code>ArrayList</code> or a <code>LinkedList</code>, as well as other collections like a <code>Map</code> or a <code>Set</code>!
<h2 id="conclusion">Conclusion</h2>
In this article, we covered the main methods used to print an array in Java. We started by using the built-in Java methods <code>toString()</code> and <code>deepToString()</code>.
From there, we used streams so that we can quickly print array elements line by line. We've also covered how to convert an array to a list, which you can either just call or use the Java 8 Stream API for more granular control.
Then, we used the traditional <code>for</code> loop structure to print every element individually.
Last but not least, we used the iterator object to print every element separately using the <code>next()</code> method inside a <code>while</code> loop. The approaches covered in the chapter can be used depending on the use case and the problem you are trying to solve.

Mohamed Echout

In this tutorial, we'll print arrays in Java using the toString() and deepToString() methods, streams, for loops and iterators, with examples and explanations!

How to Print an Array in Java

<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.

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.