<h2 id="introduction">Introduction</h2>
Working with datetimes can be challenging, and handling datetime in Python is no exception. Python's built-in <code>datetime</code> module introduced us to several classes - <code>date</code>, <code>datetime</code>, <code>time</code>, <code>timezone</code> and <code>timedelta</code>, and several external libraries have spawned to address the issues present in the official module, such as <a target="_blank" href="https://stackabuse.com/working-with-datetime-in-python-with-arrow">Arrow</a>.
In this guide, we'll take a look at how to compare datetime objects in Delorean - a library built upon <a rel="nofollow noopener" target="_blank" href="https://pypi.org/project/pytz/">pytz</a> which is the standard library for solving problems relating to timezones, and <a rel="nofollow noopener" target="_blank" href="https://dateutil.readthedocs.io/en/stable/">dateutil</a> which is used to calculate deltas between any 2 given datetime objects.
<h2 id="installingdeloreansettingupavirtualenvironment">Installing Delorean Setting Up a Virtual Environment</h2>
Delorean is available for installation via <code>pip</code>. It is generally advisable to work in a virtual environment because it enables you to organize dependencies required by different projects isolated.
On Linux, or MacOS to create a virtual environment, we'd run:
<pre><code class="hljs">$ python3 -m venv env
$ source env/bin/activate
$ python3 -m pip install delorean
</code></pre>
Alternatively, on Windows we can run:
<pre><code class="hljs">$ virtualenv env
$ .\env\Scripts\activate
$ python3 -m pip install delorean
</code></pre>
<h2 id="comparingdatetimewithouttimezonenaivedatetimeusingdelorean">Comparing Datetime without Timezone (Naive Datetime) Using Delorean</h2>
Let's start out by comparing timezone-naive dates - dates that don't carry timezone information, but represent a given point in time. That being said - you can set the <code>timezone</code> of a <code>Delorean</code> object but, when printed back, it'll be in UTC:
<pre><code class="hljs">from delorean import Delorean
import datetime

naive_d1 = Delorean(datetime=datetime.datetime(2021, 5, 15), timezone=&#x27;UTC&#x27;).naive
naive_d2 = Delorean(datetime=datetime.datetime(2021, 5, 15, 5), timezone=&#x27;UTC&#x27;).naive
naive_d3 = Delorean(datetime=datetime.datetime(2021, 5, 15, 5), timezone=&#x27;US/Central&#x27;).naive

print(&quot;naive_d1 == naive_d2 is&quot;, naive_d1 == naive_d2)
print(&quot;naive_d2 &gt; naive_d1 is&quot;, naive_d2 &gt; naive_d1)
print(&quot;naive_d3 == naive_d2 + 5h is&quot;, naive_d3 == naive_d2 + datetime.timedelta(hours=5))
</code></pre>
This results in:
<pre><code class="hljs">naive_d1 == naive_d2 is False
naive_d2 &gt; naive_d1 is True
naive_d3 == naive_d2 + 5h is True
</code></pre>
<code>naive_d1</code> is not equal to <code>naive_d2</code> because it has more information - the hours are defined, and thus aren't default (noon).
This makes <code>naive_d2</code> &quot;greater&quot; than <code>naive_d1</code>, being at a later point in time.
<code>naive_d3</code> is in a different timezone than <code>naive_d2</code>, but this is easily rectified by simply adding a <code>timedelta</code> of 5 hours to <code>naive_d2</code> to match them, and <code>True</code> is returned for their equality.
If you were to print out <code>naive_d2</code> and <code>naive_d3</code>, even though they were both set to 5AM:
<pre><code class="hljs">print(naive_d2)
print(naive_d3)
</code></pre>
You'd get a shifted result, since they're both matched to UTC:
<pre><code class="hljs">2021-05-15 05:00:00
2021-05-15 10:00:00
</code></pre>
<h2 id="comparingdatetimewithtimezoneawaredatetimeusingdelorean">Comparing Datetime with Timezone (Aware Datetime) Using Delorean</h2>
Timezone aware dates aren't matched onto a single timezone. If you were to make two dates, denoting the same clock time in two different timezones:
<pre><code class="hljs">d1 = Delorean(datetime=datetime.datetime(2021, 5, 15, 5), timezone=&#x27;UTC&#x27;)
d2 = Delorean(datetime=datetime.datetime(2021, 5, 15, 5), timezone=&#x27;Africa/Lagos&#x27;)
</code></pre>
If you were to print them out - they'd both be denoting 5AM, but in different timezones:
<pre><code class="hljs">print(d2)
print(d3)
</code></pre>
This results in:
<pre><code class="hljs">Delorean(datetime=datetime.datetime(2021, 5, 15, 5, 0), timezone=&#x27;UTC&#x27;)
Delorean(datetime=datetime.datetime(2021, 5, 15, 5, 0), timezone=&#x27;Africa/Lagos&#x27;)
</code></pre>
This makes the comparison a bit different than naive dates - is <code>d2</code> equal to <code>d3</code> here? They're both denoting the same clock time, but not the same point in time. Delorean will compare whether two <code>Delorean</code> objects denote the same point in time, so they're not the same in the library's eyes.
You can add time to dates with a timezone to match them, though. The <code>Africa/Lagos</code> timezone is just an hour behind of <code>UTC</code> so if we add an hour to it, they'll denote the same point in time:
<pre><code class="hljs">from delorean import Delorean
import datetime

d1 = Delorean(datetime=datetime.datetime(2021, 5, 15), timezone=&#x27;UTC&#x27;)
d2 = Delorean(datetime=datetime.datetime(2021, 5, 15, 5), timezone=&#x27;UTC&#x27;)
d3 = Delorean(datetime=datetime.datetime(2021, 5, 15, 5), timezone=&#x27;Africa/Lagos&#x27;)

print(&quot;d2 == d3 +1h is&quot;, d2 == d3 + datetime.timedelta(hours=1))
print(&quot;d1 &gt; d3 -&quot;, d1 &gt; d3)
</code></pre>
Additionally, since <code>d1</code> doesn't have data on hours - it's set to noon. Even though <code>d1</code> belongs to <code>UTC</code>, it's still 4 hours before <code>d3</code>:
<pre><code class="hljs">d2 == d3 +1h is True
d1 &gt; d3 is False
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to compare timezone-naive and timezone-aware dates in Delorean.

David Landup

Geoffery, Joseph

In this guide, we've taken a look at how to compare dates in Python with Delorean - both for timezone aware and timezone naive datetime objects.

Comparing Datetime with Delorean in Python - With and Without Timezones

<h2 id="introduction">Introduction</h2>
Calculating a factorial of a number is a straightforward task. A factorial of a number is the product of that number (positive integer) and all positive integers less than that number. In other words - multiplying a number by all of the whole numbers from that number to 1.
<blockquote>
0! equals 1 as well, since you can't exactly go down from 0 to 1.
</blockquote>
It's simply an agreement that 0! is equal to 1, and a common explanation of this (sadly unattributable to a single person) is: 'Because there is exactly one way to do nothing.'
A factorial is denoted by the integer and followed by an exclamation mark.
<blockquote>
5! denotes a factorial of five. Alternatively, you can simply say five factorial.
</blockquote>
And to calculate that factorial, we multiply the number with every positive whole number smaller than it:
$$ 
5! = 5 * 4 * 3 * 2 * 1 
5! = 120 
$$
In this tutorial, we'll learn how to calculate a factorial of an integer in Java. This can be done using loops or recursion - though recursion is arguably a more natural approach. Of course, you should implement the one you're more comfortable with.
<h2 id="calculatingfactorialusingloops">Calculating Factorial Using Loops</h2>
Let's start out calculating factorials using loops - <code>while</code> and <code>for</code>. We can also use <code>do-while</code> loops, but the initial <code>do</code> block doesn't do much for us here and would introduce a potential erroneous edge-case, so we'll skip it.
The general process is pretty similar for both loop types - all we need is a parameter as input and a counter to iterate over the numbers.
Let's start with the <code>for</code> loop:
<pre><code class="hljs">public static int getFactorialForLoop(int n) {
 int result = 1;
 if (n &gt; 1) {
 for (int i = 1; i &lt;= n; i++) {
 result = result * i;
 }
 return result;
 }
 else {
 System.out.println(&quot;n has to be positive&quot;);
 return result;
 }
}
</code></pre>
We've actually strayed a bit away from the original definition here - we're counting from 1 to <code>n</code>, while the definition of factorial was from the given number down to 1.
When you put it down on paper, though, mathematically:
$$ 
1 * 2 * 3 * 4 ... * n = n * (n-1) * (n-2) * (n-3) * (n-4) ... * (n - (n-1)) 
$$
These are equal statements, and you can really either go from 1 to <code>n</code>, or the other way around.
<blockquote>
To simplify, <code>(n - (n-1))</code> will always be equal to 1.
</blockquote>
That means that it doesn't matter in which direction we're iterating. It can start from 1 and increase towards the <code>n</code>, or it can start from <code>n</code> and decrease towards 1.
<blockquote>
Why?
</blockquote>
Well, if you turn the loop the other way around, the method doesn't get much more complicated, but it's just a little bit less clean:
<pre><code class="hljs">public static int getFactorialForLoop(int n) {
 int result = n;
 if (n &gt;= 1) {
 for (int i = n-1; i &gt;= 1; i--) {
 result = result * i;
 }
 return result;
 }
 else {
 System.out.println(&quot;n has to be positive&quot;);
 return 1;
 }
}
</code></pre>
Now that that's clarified, let's start breaking the method down.
It takes in a parameter, <code>n</code>, which denotes the number we're calculating a factorial for. First, we define a variable named <code>result</code> and assign <code>1</code> as a value to it.
<blockquote>
Why assign 1 and not 0?
</blockquote>
If we were to assign 0 to it then all the following multiplications would contain that 0. Naturally, it would collapse the entire operation to a huge 0.
Then we start our <code>for</code> loop with defining <code>i</code> as the counter that starts from <code>1</code>. Notice that the condition statement is <code>i &lt;= n;</code> in order to include the <code>n</code> itself as well.
Inside the <code>for</code> loop, we multiply the current value of <code>result</code> with the current value of our index <code>i</code>.
Finally, we return the final value of the <code>result</code>. In order to get input from the user, remember to import the <code>java.util.Scanner</code>.
<blockquote>
If you'd like to read more about getting user input in Java - read our <a target="_blank" href="https://stackabuse.com/how-to-get-user-input-in-java/">Guide to the Scanner class</a>.
</blockquote>
Let's test our method and print the results:
<pre><code class="hljs">Scanner scanner = new Scanner(System.in);
int inp;
 
System.out.println(&quot;Enter a number: &quot;); 
inp = Integer.parseInt(scanner.nextLine()); 
 
System.out.println(&quot;The result is: &quot; + getFactorialForLoop(inp)); 

 
public static int getFactorialForLoop(int n) {
 int result = 1;
 if (n &gt;= 1) {
 for (int i = 1; i &lt;= n; i++) {
 result = result * i;
 }
 return result;
 }
 else {
 System.out.println(&quot;n has to be positive&quot;);
 return result;
 }
</code></pre>
It will prompt the user to give input. We'll try it with <code>4</code>:
<pre><code class="hljs">Enter a number: 4
The result is: 24
</code></pre>
You can use a calculator to verify the result:
4! is <code>4 * 3 * 2 * 1</code>, which results 24.
Now let's see how we can calculate factorial using the <code>while</code> loop. Here's our modified method:
<pre><code class="hljs">public static int getFactorialWhileLoop(int n){
 int result = 1;
 while (n &gt; 1) {
 result = result * n;
 n -= 1;
 }
 return result;
}
</code></pre>
This is pretty similar to the <code>for</code> loop. Except that, this time we're moving from <code>n</code> towards the 1, closer to the mathematical definition. Let's test our method:
<pre><code class="hljs">System.out.println(&quot;Enter a number: &quot;); 
inp = Integer.parseInt(scanner.nextLine()); 
 
System.out.println(&quot;The result is: &quot; + getFactorialWhileLoop(inp)); 
</code></pre>
We'll enter 4 as an input once more:
<pre><code class="hljs">Enter a number: 4
The result is: 24
</code></pre>
Although the calculation was <code>4*3*2*1</code> the final result is the same as before.
Now let's take a look at how to calculate the factorial using a recursive method.
<h2 id="calculatingfactorialusingrecursion">Calculating Factorial Using Recursion</h2>
A recursive method is a method that calls itself and terminates the call given some condition.
In general, every recursive method has two main components: a base case and a recursive step.
Base cases are the smallest instances of the problem. Also, they must have a break, a case that will return a value and will break out of the recursion. In terms of factorial methods, the base case is when we return the final element of the factorial, which is 1.
<blockquote>
Without a base case or with an incorrect base case, your recursive method can run infinitely, causing an overflow.
</blockquote>
Recursive steps - as the name implies, are the recursive part of the method, where the whole problem is transformed into something smaller. If the recursive step fails to shrink the problem, then again recursion can run infinitely.
Consider the recurring part of the factorials:
<ul>
<li>5! is <code>5 * 4 * 3 * 2 * 1</code>.</li>
</ul>
But we also know that:
<ul>
<li>4! is <code>4 * 3 * 2 * 1</code>.</li>
</ul>
In other words 5! is <code>5 * 4!</code>, and 4! is <code>4 * 3!</code> and so on.
<blockquote>
So we can say that <code>n! = n * (n-1)!</code>. This will be the recursive step of our factorial!
</blockquote>
A factorial recursion ends when it hits 1. This will be our base case. We will return <code>1</code> if <code>n</code> is <code>1</code> or less, covering the zero input.
Let's take a look at our recursive factorial method:
<pre><code class="hljs">public static int getFactorialRecursively(int n){
 if (n &lt;= 1){
 return 1;
 }
 else {
 return n * getFactorialRecursively(n-1);
 }
}
</code></pre>
As you see the <code>if</code> block embodies our base case, while the <code>else</code> block covers the recursive step.
Let's test our method:
<pre><code class="hljs">System.out.println(&quot;Enter a number: &quot;); 
inp = Integer.parseInt(scanner.nextLine()); 
 
System.out.println(&quot;The result is: &quot; + getFactorialRecursively(inp)); 
</code></pre>
We will enter 3 as input this time:
<pre><code class="hljs">Enter a number:3
The result is: 6
</code></pre>
We get the same result. But this time, what goes under the hood is rather interesting:
You see, when we enter the input, the method will check with the <code>if</code> block, and since 3 is greater than 1, it will skip to the <code>else</code> block. In this block, we see the line <code>return n * getFactorialRecursively(n-1);</code>.
<blockquote>
We know the current value of <code>n</code> for the moment, it's <code>3</code>, but <code>getFactorialRecursively(n-1)</code> is still to be calculated.
</blockquote>
Then the program calls the same method once more, but this time our method takes 2 as the parameter. It checks the <code>if</code> block and skips to the <code>else</code> block and again encounters the last line. Now, the current value of the <code>n</code> is <code>2</code> but the program still must calculate the <code>getFactorialRecursively(n-1)</code>.
So it calls the method once again, but this time the <code>if</code> block, or rather, the base class succeeds to return 1 and breaks out from the recursion.
Following the same pattern upwards, it returns each method result, multiplying the current result with the previous <code>n</code> and returning it for the previous method call. In other words, our program first gets to the bottom of the factorial (which is 1), then builds its way up, while multiplying on each step.
Also removing the method from the call stack one by one, up until the final result of the <code>n * (n-1)</code> is returned.
This is generally how recursive methods work. Some more complicated problems may require deeper recursions with more than one base case or more than one recursive step. But for now, this simple recursion is good enough to solve our factorial problem!
<h2 id="calculatingfactorialforlargenumbers">Calculating Factorial for Large Numbers</h2>
Factorials get large pretty quickly. Everyone knows how exponentials tend to get huge given a small number of steps:
$$ 
2^6 = 64 
$$
$$ 
6! = 720 
$$
As a matter of fact, a factorial of just 20 is equal to:
$$ 
20! = 2,432,902,008,176,640,000 
$$
That's 2.4 quintillion. The next factorial is 51 quintillion, which is out of range even for <code>long</code>s in Java, which stands at ~9 quintillion. Integers run out at a mere 2.4 billion, so they're out of the question pretty quickly.
This is where a <code>BigInteger</code> comes into play - the JVM doesn't pre-allocate known space for the number and dynamically updates its size. You can fill the entire RAM with digits for a <code>BigInteger</code> and only then would you run into the limit:
<pre><code class="hljs">public static BigInteger getFactorialRecursively(int n) {
 BigInteger value = BigInteger.valueOf(n);
 if (value == BigInteger.ZERO) {
 return BigInteger.ONE;
 } else {
 return value.multiply(getFactorialRecursively(n - 1));
 }
}
</code></pre>
Chucking in <code>21</code> into this method would result in:
<pre><code class="hljs">51090942171709440000
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we covered how to calculate factorials using <code>for</code> and <code>while</code> loops. We also learned what recursion is, and how to calculate factorial using recursion.

Marcus Sanatan

Ruslan Hasanov

In this article you will learn how to calculate the factorial of an integer with Java, using loops and recursion.

Calculate Factorial With Java - Iterative and Recursive

<h2 id="introduction">Introduction</h2>
A factorial of a number is the product of that integer and all the positive integers that are lesser than or equal to it. It has to be a positive integer - otherwise, the logic extends to negative infinity. In other words - calculating a factorial means multiplying all whole numbers between a number and 1.
<blockquote>
0! equals 1, by convention, and doesn't follow the standard rule.
</blockquote>
A factorial is denoted by the integer we're calculating a factorial for, followed by an exclamation mark.
<blockquote>
5! denotes a factorial of five.
</blockquote>
And to calculate that factorial, we multiply the number with every whole number smaller than it, until we reach 1:
<pre><code class="hljs">5! = 5 * 4 * 3 * 2 * 1
5! = 120
</code></pre>
In this tutorial, we will learn how to calculate the factorial of an integer with JavaScript, using loops and recursion.
<h2 id="calculatingfactorialusingloops">Calculating Factorial Using Loops</h2>
We can calculate factorials using both the <code>while</code> loop and the <code>for</code> loop. We'll generally just need a counter for the loop's termination and the supplied number we're calculating a factorial for.
Let's start with the <code>for</code> loop:
<pre><code class="hljs">function getFactorialForLoop(n) {
 let result = 1;
 if (n &gt; 1) {
 for (let i = 1; i &lt;= n; i++) {
 result = result * i;
 }
 return result;
 }
 else {
 return &quot;n has to be positive&quot;;
 }
}
</code></pre>
You've probably been able to observe that we're starting the count at 1, not <code>n</code> - even though the definition of a factorial states that we go from <code>n</code> to 1. Though, mathematically, these are equivalent statements:
$$ 
1 * 2 * 3 * 4 ... * n = n * (n-1) * (n-2) * (n-3) * (n-4) ... * (n - (n-1)) 
$$
<blockquote>
To simplify, <code>(n - (n-1))</code> will always be equal to 1.
</blockquote>
That means that it doesn't matter in which direction we're counting. It can start from 1 and increase towards <code>n</code>, or it can start from <code>n</code> and decrease towards 1. Now that that's clarified, let's take a look at what happens in this method.
It accepts <code>n</code>, the number we're calculating a factorial for. A value of <code>1</code> is assigned to a placeholder <code>result</code> variable that will eventually be updated.
<blockquote>
Why assign 1 and not 0 or other blanks?
</blockquote>
If we were to assign 0 to it - all of the following multiplications would be with a 0. This ends up with just a 0 at the end.
Then we start our <code>for</code> loop with defining <code>i</code> as the counter that starts from <code>1</code>. Notice that the condition statement is <code>i &lt;= n;</code> in order to include the <code>n</code> itself as well.
Inside the <code>for</code> loop, we multiply the current value of <code>result</code> with the current value of our index <code>i</code> - performing the operation from the definition in reverse.
Finally, we return the final value of the <code>result</code> as the output of the method. Let's test our function in our browser's console and print out the result. Be sure to enter the factorial function in the browser's console first:
<pre><code class="hljs">var inp = window.prompt(&quot;Enter a number: &quot;);
inp = parseInt(inp);

alert(&quot;The result is: &quot; + getFactorialForLoop(inp));
</code></pre>
It will prompt the user to give input. We'll try it with <code>4</code>. When you run the alert script, you'll see a pop-up with the result:
<pre><code class="hljs">24
</code></pre>
You can use a calculator to verify the result:
4! is <code>4 * 3 * 2 * 1</code>, which results 24.
Now let's see how we can calculate factorial using the <code>while</code> loop. Here's our modified function:
<pre><code class="hljs">function getFactorialWhileLoop(n) {
 let result = 1;
 while (n &gt; 1) {
 result = result * n;
 n -= 1;
 }
 return result;
}
</code></pre>
This is pretty similar to the <code>for</code> loop. Except for this time we're moving from <code>n</code> towards the 1 - closer to the mathematical definition. Let's test our function:
<pre><code class="hljs">var inp = window.prompt(&quot;Enter a number: &quot;);
inp = parseInt(inp);

alert(&quot;The result is: &quot; + getFactorialWhileLoop(inp));
</code></pre>
Like before, if we enter <code>4</code> we get <code>24</code>. The calculation was <code>4*3*2*1</code> and the final result is the same as before.
Factorials are recursive in nature, and using recursion is a more natural approach to repeating an operation such as this multiple times.
<h2 id="calculatingfactorialusingrecursion">Calculating Factorial Using Recursion</h2>
A recursive function is a function that calls itself. It may sound a bit intimidating at first but bear with us and you'll see that recursive functions are easy to understand.
In general, every recursive function has two main components: a base case and a recursive step.
Base cases are the smallest instances of the problem - that's what repeats. Also a break, a case that will return a value and will get out of the recursion. In terms of factorial functions, the base case is when we return the final element of the factorial, which is 1.
<blockquote>
Without a base case or with an incorrect base case, your recursive function can run infinitely, causing an overflow.
</blockquote>
Recursive steps - as the name implies- are the recursive part of the function, where the whole problem is transformed into something smaller. If the recursive step fails to shrink the problem, then again recursion can run infinitely.
Consider the recurring part of the factorials:
<ul>
<li>5! is <code>5 * 4 * 3 * 2 * 1</code>.</li>
</ul>
But we also know that:
<ul>
<li><code>4 * 3 * 2 * 1</code> is 4!.</li>
</ul>
In other words 5! is <code>5 * 4!</code>, and 4! is <code>4 * 3!</code> and so on.
<blockquote>
So we can say that <code>n! = n * (n-1)!</code>. This will be the recursive step of our factorial!
</blockquote>
A factorial recursion ends when it hits 1. This will be our base case. We will return <code>1</code> if <code>n</code> is <code>1</code> or less, covering the zero input.
Let's take a look at our recursive factorial function:
<pre><code class="hljs">function getFactorialRecursively(n) {
 if (n &lt;= 1) {
 return 1;
 }
 else{
 return n * getFactorialRecursively(n-1);
 }
}
</code></pre>
As you see the <code>if</code> block embodies our base case, while the <code>else</code> block covers the recursive step.
Let's test our function:
<pre><code class="hljs">var inp = window.prompt(&quot;Enter a number: &quot;);
inp = parseInt(inp);

alert(&quot;The result is: &quot; + getFactorialRecursively(inp));
</code></pre>
We will enter <code>3</code> as input this time, and the alert will print <code>6</code> as the result.
We get the same result. But this time, what goes under the hood is rather interesting:
You see, when we enter the input, the function will check with the <code>if</code> block, and since 3 is greater than 1, it will skip to the <code>else</code> block. In this block, we see the line <code>return n * getFactorialRecursively(n-1);</code>.
<blockquote>
We know the current value of <code>n</code> for the moment, it's <code>3</code>, but <code>getFactorialRecursively(n-1)</code> is still to be calculated.
</blockquote>
Then the program calls the same function once more, but this time our function takes 2 as the parameter. It checks the <code>if</code> block and skips to the <code>else</code> block and again encounters the last line. Now, the current value of the <code>n</code> is <code>2</code> but the program still must calculate the <code>getFactorialRecursively(n-1)</code>.
So it calls the function once again, but this time the <code>if</code> block, or rather, the base class succeeds to return 1 and breaks out from the recursion.
Following the same pattern upwards, it returns each function result, multiplying the current result with the previous <code>n</code> and returning it for the previous function call. In other words, our program first gets to the bottom of the factorial (which is 1), then builds its way up, while multiplying on each step.
Also removing the function from the call stack one by one, up until the final result of the <code>n * (n-1)</code> is returned.
This is generally how recursive functions work. Some more complicated problems may require deeper recursions with more than one base case or more than one recursive step. But for now, this simple recursion is good enough to solve our factorial problem!
<h2 id="conclusion">Conclusion</h2>
In this article, we covered how to calculate factorials using <code>for</code> and <code>while</code> loops. We also learned what recursion is, and how to calculate factorial using recursion.
If you've enjoyed the recursion and want to practice more, try calculating the Fibonacci sequence with recursion! And if you have any questions or thoughts about our article, feel free to share in the comment section.

In this article you will learn how to calculate the factorial of an integer with JavaScript, using loops and recursion.

Calculate Factorial With JavaScript - Iterative and Recursive

<h2 id="introduction">Introduction</h2>
The Portable Document Format (PDF) is not a WYSIWYG (What You See is What You Get) format. It was developed to be platform-agnostic, independent of the underlying operating system and rendering engines.
To achieve this, PDF was constructed to be interacted with via something more like a programming language, and relies on a series of instructions and operations to achieve a result. In fact, PDF is based on a scripting language - <a rel="nofollow noopener" target="_blank" href="https://www.adobe.com/products/postscript.html">PostScript</a>, which was the first device-independent Page Description Language.
In this guide, we'll be using <a rel="nofollow noopener" target="_blank" href="https://borbpdf.com/">borb</a> - a Python library dedicated to reading, manipulating and generating PDF documents. It offers both a low-level model (allowing you access to the exact coordinates and layout if you choose to use those) and a high-level model (where you can delegate the precise calculations of margins, positions, etc to a layout manager).
<blockquote>
In this guide, we'll take a look at how to process a PDF invoice in Python using borb, by extracting text, since PDF is an extractable format - which makes it prone to automated processing.
</blockquote>
Automating processing is one of the fundamental goals of machines, and if someone doesn't supply a parsable document, such as <code>json</code> alongside a human-oriented invoice - you'll have to parse the PDF contents yourself.
<h2 id="installingborb">Installing borb</h2>
borb can be downloaded from source on <a rel="nofollow noopener" target="_blank" href="https://github.com/jorisschellekens/borb">GitHub</a>, or installed via <code>pip</code>:
<pre><code class="hljs">$ pip install borb
</code></pre>
<h2 id="creatingapdfinvoiceinpythonwithborb">Creating a PDF Invoice in Python with borb</h2>
In the previous guide, we've generated a PDF invoice, using borb, which we'll now be processing.
<blockquote>
If you'd like to read more about <a target="_blank" href="https://stackabuse.com/creating-pdf-invoices-in-python-with-borb/">How to Create Invoices in Python with borb</a>, we've got you covered!
</blockquote>
The generated PDF document specifically looks like this:
<img src="https://s3.stackabuse.com/media/articles/creating-pdf-invoices-in-python-with-ptext-6.PNG" alt="borb invoice 5">
<h2 id="processingapdfinvoicewithborb">Processing a PDF Invoice with borb</h2>
Let's start by opening the PDF file and loading it into a <code>Document</code> - the object-representation of the file:
<pre><code class="hljs">import typing
from borb.pdf.document import Document
from borb.pdf.pdf import PDF

def main():
 d: typing.Optional[Document] = None
 with open(&quot;output.pdf&quot;, &quot;rb&quot;) as pdf_in_handle:
 d = PDF.loads(pdf_in_handle)

 assert d is not None


if __name__ == &quot;__main__&quot;:
 main()
</code></pre>
The code follows the same pattern you might see in the <code>json</code> library; a static method, <code>loads()</code>, which accepts a file-handle, and outputs a data structure.
Next, we'd like to be able to extract all the text contents of the file. <code>borb</code> enables this by allowing you to register <code>EventListener</code> classes to the parsing of the <code>Document</code>.
For instance, whenever <code>borb</code> encounters some kind of text-rendering instruction it will notify all registered <code>EventListener</code> objects, which can then process the emitted <code>Event</code>.
<code>borb</code> comes with quite a few implementations of <code>EventListener</code>:
<ul>
<li><code>SimpleTextExtraction</code> : Extracts text from a PDF</li>
<li><code>SimpleImageExtraction</code>: Extracts all images from a PDF</li>
<li><code>RegularExpressionTextExtraction</code>: Matches a regular expression, and returns the matches per page</li>
<li>etc.</li>
</ul>
We'll start by extracting all the text:
<pre><code class="hljs">import typing
from borb.pdf.document import Document
from borb.pdf.pdf import PDF

# New import
from borb.toolkit.text.simple_text_extraction import SimpleTextExtraction

def main():

 d: typing.Optional[Document] = None
 l: SimpleTextExtraction = SimpleTextExtraction()
 with open(&quot;output.pdf&quot;, &quot;rb&quot;) as pdf_in_handle:
 d = PDF.loads(pdf_in_handle, [l])

 assert d is not None
 print(l.get_text_for_page(0))


if __name__ == &quot;__main__&quot;:
 main()
</code></pre>
This code-snippet should print all the text in the invoice, in reading order (top to bottom, left to right):
<pre><code class="hljs">[Street Address] Date 6/5/2021
[City, State, ZIP Code] Invoice # 1741
[Phone] Due Date 6/5/2021
[Email Address]
[Company Website]
BILL TO SHIP TO
[Recipient Name] [Recipient Name]
[Company Name] [Company Name]
[Street Address] [Street Address]
[City, State, ZIP Code] [City, State, ZIP Code]
[Phone] [Phone]
DESCRIPTION QTY UNIT PRICE AMOUNT
Product 1 2 $ 50 $ 100
Product 2 4 $ 60 $ 240
Labor 14 $ 60 $ 840
Subtotal $ 1,180.00
Discounts $ 177.00
Taxes $ 100.30
Total $ 1163.30
</code></pre>
This is of course not very useful to us as this would require more processing before we can do much with it, though this is a great start, especially compared to OCR-scanned PDF documents!
<blockquote>
Let's refine this code and tell <code>borb</code> which <code>Rectangle</code> we are interested in.
</blockquote>
For instance, let's extract the shipping information (but you can modify the code to retrieve any area of interest).
In order to allow <code>borb</code> to filter out a <code>Rectangle</code> we'll be using the <code>LocationFilter</code> class. This class implements <code>EventListener</code>. It gets notified of all <code>Events</code> when rendering the <code>Page</code> and passes those (to its children) that occur inside predefined bounds:
<pre><code class="hljs">import typing
from decimal import Decimal

from borb.pdf.document import Document
from borb.pdf.pdf import PDF
from borb.toolkit.text.simple_text_extraction import SimpleTextExtraction

# New import
from borb.toolkit.location.location_filter import LocationFilter
from borb.pdf.canvas.geometry.rectangle import Rectangle

def main():

 d: typing.Optional[Document] = None

 # Define rectangle of interest
 # x, y, width, height
 r: Rectangle = Rectangle(Decimal(280),
 Decimal(510),
 Decimal(200),
 Decimal(130))

 # Set up EventListener(s)
 l0: LocationFilter = LocationFilter(r)
 l1: SimpleTextExtraction = SimpleTextExtraction()
 l0.add_listener(l1)

 with open(&quot;output.pdf&quot;, &quot;rb&quot;) as pdf_in_handle:
 d = PDF.loads(pdf_in_handle, [l0])

 assert d is not None
 print(l1.get_text_for_page(0))


if __name__ == &quot;__main__&quot;:
 main()
</code></pre>
Running this code, assuming that the right rectangle is chosen, prints:
<pre><code class="hljs">SHIP TO
[Recipient Name]
[Company Name]
[Street Address]
[City, State, ZIP Code]
[Phone]
</code></pre>
This code is not exactly the most flexible or future-proof. It takes some fiddling to find the right <code>Rectangle</code>, and there is no guarantee it will work if the layout of the invoice changes even slightly.
<blockquote>
We're going to have to build something more robust, to have actual practical application.
</blockquote>
We can start by removing the hard-coded <code>Rectangle</code>. <code>RegularExpressionTextExtraction</code> can match a regular expression and return (among other things) its coordinates on the <code>Page</code>! Using pattern-matching, we can search for elements in a document automatically and retrieve them, instead of guessing where to draw a rectangle.
Let's use this class to find the words &quot;SHIP TO&quot;, and build a <code>Rectangle</code> based on those coordinates:
<pre><code class="hljs">import typing
from borb.pdf.document import Document
from borb.pdf.pdf import PDF
from borb.pdf.canvas.geometry.rectangle import Rectangle

# New imports
from borb.toolkit.text.regular_expression_text_extraction import RegularExpressionTextExtraction, PDFMatch

def main():

 d: typing.Optional[Document] = None
 
 # Set up EventListener
 l: RegularExpressionTextExtraction = RegularExpressionTextExtraction(&quot;SHIP TO&quot;)
 with open(&quot;output.pdf&quot;, &quot;rb&quot;) as pdf_in_handle:
 d = PDF.loads(pdf_in_handle, [l])

 assert d is not None

 matches: typing.List[PDFMatch] = l.get_matches_for_page(0)
 assert len(matches) == 1

 r: Rectangle = matches[0].get_bounding_boxes()[0]
 print(&quot;%f %f %f %f&quot; % (r.get_x(), r.get_y(), r.get_width(), r.get_height()))

if __name__ == &quot;__main__&quot;:
 main()
</code></pre>
Here, we've built a <code>Rectangle</code> around the section and printed its coordinates:
<pre><code class="hljs">299.500000 621.000000 48.012000 8.616000
</code></pre>
You will have noticed that <code>get_bounding_boxes()</code> returns <code>typing.List[Rectangle]</code>. This is the case when a regular expression is matched across multiple lines of text in the PDF.
<blockquote>
Also, keep in mind the origin of a PDF (the <code>[0, 0]</code> point) is located in the bottom left corner. So the top of the <code>Page</code> has the highest Y-coordinate.
</blockquote>
Now that we know where to find &quot;SHIP TO&quot;, we can update our earlier code to place the <code>Rectangle</code> of interest just underneath those words:
<pre><code class="hljs">import typing
from decimal import Decimal

from borb.pdf.document import Document
from borb.pdf.pdf import PDF
from borb.pdf.canvas.geometry.rectangle import Rectangle
from borb.toolkit.location.location_filter import LocationFilter
from borb.toolkit.text.regular_expression_text_extraction import RegularExpressionTextExtraction, PDFMatch
from borb.toolkit.text.simple_text_extraction import SimpleTextExtraction

def find_ship_to() -&gt; Rectangle:

 d: typing.Optional[Document] = None

 # Set up EventListener
 l: RegularExpressionTextExtraction = RegularExpressionTextExtraction(&quot;SHIP TO&quot;)
 with open(&quot;output.pdf&quot;, &quot;rb&quot;) as pdf_in_handle:
 d = PDF.loads(pdf_in_handle, [l])

 assert d is not None

 matches: typing.List[PDFMatch] = l.get_matches_for_page(0)
 assert len(matches) == 1

 return matches[0].get_bounding_boxes()[0]
def main():

 d: typing.Optional[Document] = None

 # Define rectangle of interest
 ship_to_rectangle: Rectangle = find_ship_to()
 r: Rectangle = Rectangle(ship_to_rectangle.get_x() - Decimal(50),
 ship_to_rectangle.get_y() - Decimal(100),
 Decimal(200),
 Decimal(130))

 # Set up EventListener(s)
 l0: LocationFilter = LocationFilter(r)
 l1: SimpleTextExtraction = SimpleTextExtraction()
 l0.add_listener(l1)

 with open(&quot;output.pdf&quot;, &quot;rb&quot;) as pdf_in_handle:
 d = PDF.loads(pdf_in_handle, [l0])

 assert d is not None
 print(l1.get_text_for_page(0))

if __name__ == &quot;__main__&quot;:
 main()
</code></pre>
And this code prints:
<pre><code class="hljs">SHIP TO
[Recipient Name]
[Company Name]
[Street Address]
[City, State, ZIP Code]
[Phone]
</code></pre>
This still requires some knowledge of the document, but isn't nearly as rigid as the previous approach - and as long as you know which text you'd like to extract - you can get coordinates and snatch the contents within a rectangle on the page.
<h2 id="conclusion">Conclusion</h2>
In this guide we've taken a look at how to process an invoice in Python using borb. We've started by extracting all the text, and refined our process to extract only a region of interest. Finally, we matched a regular expression against a PDF to make the process even more robust and future-proof.

Joris Schellekens

In this guide, we'll take a look at how to automate the processing and extraction of text from PDF Invoices in Python with the borb library.

Extract and Process PDF Invoices in Python with borb

In this guide, we'll take a look at practical examples of how to use the @Query annotation of Spring Data JPA, how named and indexed parametrization works and how to paginate and sort query results.

Spring Data JPA - Guide to the @Query Annotation

Vladimir Batoćanin

Lazar Ristic

In this guide, we'll be getting started with Collections in JavaScript for beginners, with practical examples and explanations of Indexed Collections, Keyed Collections and HTML DOM Collections.

Getting Started with Collections in JavaScript

<h2 id="introduction">Introduction</h2>
By definition, a factorial is the product of a positive integer and all the positive integers that are less than or equal to the given number. In other words, getting a factorial of a number means to multiply all whole numbers from that number, down to 1.
<blockquote>
0! equals 1 as well, by convention.
</blockquote>
A factorial is denoted by the integer and followed by an exclamation mark.
<blockquote>
5! denotes a factorial of five.
</blockquote>
And to calculate that factorial, we multiply the number with every whole number smaller than it, until we reach 1:
<pre><code class="hljs">5! = 5 * 4 * 3 * 2 * 1
5! = 120
</code></pre>
Keeping these rules in mind, in this tutorial, we will learn how to calculate the factorial of an integer with Python, using loops and recursion. Let's start with calculating the factorial using loops.
<h2 id="calculatingfactorialusingloops">Calculating Factorial Using Loops</h2>
We can calculate factorials using both the <code>while</code> loop and the <code>for</code> loop. The general process is pretty similar for both. All we need is a parameter as input and a counter.
Let's start with the <code>for</code> loop:
<pre><code class="hljs">def get_factorial_for_loop(n):
 result = 1
 if n &gt; 1:
 for i in range(1, n+1):
 result = result * i
 return result
 else:
 return &#x27;n has to be positive&#x27;
</code></pre>
You may have noticed that we are counting starting from 1 to the <code>n</code>, whilst the definition of factorial was from the given number down to 1. But mathematically:
$$ 
1 * 2 * 3 * 4 ... * n = n * (n-1) * (n-2) * (n-3) * (n-4) ... * (n - (n-1)) 
$$
<blockquote>
To simplify, <code>(n - (n-1))</code> will always be equal to 1.
</blockquote>
That means that it doesn't matter in which direction we're counting. It can start from 1 and increase towards the <code>n</code>, or it can start from <code>n</code> and decrease towards 1. Now that's clarified, let's start breaking down the function we've just wrote.
Our function takes in a parameter <code>n</code> which denotes the number we're calculating a factorial for. First, we define a variable named <code>result</code> and assign <code>1</code> as a value to it.
<blockquote>
Why assign 1 and not 0 you ask?
</blockquote>
Because if we were to assign 0 to it then all the following multiplications with 0, naturally would result in a huge 0.
Then we start our <code>for</code> loop in the range from <code>1</code> to <code>n+1</code>. Remember, the Python range will stop before the second argument. To include the last number as well, we simply add an additional <code>1</code>.
Inside the <code>for</code> loop, we multiply the current value of <code>result</code> with the current value of our index <code>i</code>.
Finally, we return the final value of the <code>result</code>. Let's test our function print out the result:
<pre><code class="hljs">inp = input(&quot;Enter a number: &quot;)
inp = int(inp)

print(f&quot;The result is: {get_factorial_for_loop(inp)}&quot;)
</code></pre>
<blockquote>
If you'd like to read more about how to get user input, read our <a target="_blank" href="https://stackabuse.com/getting-user-input-in-python/">Getting User Input in Python</a>.
</blockquote>
It will prompt the user to give input. We'll try it with <code>4</code>:
<pre><code class="hljs">Enter a number: 4
The result is: 24
</code></pre>
You can use a calculator to verify the result:
4! is <code>4 * 3 * 2 * 1</code>, which results 24.
Now let's see how we can calculate factorial using the <code>while</code> loop. Here's our modified function:
<pre><code class="hljs">def get_factorial_while_loop(n):
 result = 1
 while n &gt; 1:
 result = result * n
 n -= 1
 return result
</code></pre>
This is pretty similar to the <code>for</code> loop. Except for this time we're moving from <code>n</code> towards the 1, closer to the mathematical definition. Let's test our function:
<pre><code class="hljs">inp = input(&quot;Enter a number: &quot;)
inp = int(inp)

print(f&quot;The result is: {get_factorial_while_loop(inp)}&quot;)
</code></pre>
We'll enter 4 as an input once more:
<pre><code class="hljs">Enter a number: 4
The result is: 24
</code></pre>
Although the calculation was <code>4 * 3 * 2 * 1</code> the final result is the same as before.
Calculating factorials using loops was easy. Now let's take a look at how to calculate the factorial using a recursive function.
<h2 id="calculatingfactorialusingrecursion">Calculating Factorial Using Recursion</h2>
A recursive function is a function that calls itself. It may sound a bit intimidating at first but bear with us and you'll see that recursive functions are easy to understand.
In general, every recursive function has two main components: a base case and a recursive step.
Base cases are the smallest instances of the problem. Also a break, a case that will return a value and will get out of the recursion. In terms of factorial functions, the base case is when we return the final element of the factorial, which is 1.
<blockquote>
Without a base case or with an incorrect base case, your recursive function can run infinitely, causing an overflow.
</blockquote>
Recursive steps - as the name implies- are the recursive part of the function, where the whole problem is transformed into something smaller. If the recursive step fails to shrink the problem, then again recursion can run infinitely.
Consider the recurring part of the factorials:
<ul>
<li>5! is <code>5 * 4 * 3 * 2 * 1</code>.</li>
</ul>
But we also know that:
<ul>
<li><code>4 * 3 * 2 * 1</code> is 4!.</li>
</ul>
In other words 5! is <code>5 * 4!</code>, and 4! is <code>4 * 3!</code> and so on.
<blockquote>
So we can say that <code>n! = n * (n-1)!</code>. This will be the recursive step of our factorial!
</blockquote>
A factorial recursion ends when it hits 1. This will be our base case. We will return <code>1</code> if <code>n</code> is <code>1</code> or less, covering the zero input.
Let's take a look at our recursive factorial function:
<pre><code class="hljs">def get_factorial_recursively(n):
 if n &lt;= 1:
 return 1
 else:
 return n * get_factorial_recursively(n-1)
</code></pre>
As you see the <code>if</code> block embodies our base case, while the <code>else</code> block covers the recursive step.
Let's test our function:
<pre><code class="hljs">inp = input(&quot;Enter a number: &quot;)
inp = int(inp)

print(f&quot;The result is: {get_factorial_recursively(inp)}&quot;)
</code></pre>
We will enter 3 as input this time:
<pre><code class="hljs">Enter a number:3
The result is: 6
</code></pre>
We get the same result. But this time, what goes under the hood is rather interesting:
You see, when we enter the input, the function will check with the <code>if</code> block, and since 3 is greater than 1, it will skip to the <code>else</code> block. In this block, we see the line <code>return n * get_factorial_recursively(n-1)</code>.
<blockquote>
We know the current value of <code>n</code> for the moment, it's <code>3</code>, but <code>get_factorial_recursively(n-1)</code> is still to be calculated.
</blockquote>
Then the program calls the same function once more, but this time our function takes 2 as the parameter. It checks the <code>if</code> block and skips to the <code>else</code> block and again encounters with the last line. Now, the current value of the <code>n</code> is <code>2</code> but the program still must calculate the <code>get_factorial_recursively(n-1)</code>.
So it calls the function once again, but this time the <code>if</code> block, or rather, the base class succeeds to return 1 and breaks out from the recursion.
Following the same pattern to upwards, it returns each function result, multiplying the current result with the previous <code>n</code> and returning it for the previous function call. In other words, our program first gets to the bottom of the factorial (which is 1), then builds its way up, while multiplying on each step.
Also removing the function from the call stack one by one, up until the final result of the <code>n * (n-1)</code> is returned.
This is generally how recursive functions work. Some more complicated problems may require deeper recursions with more than one base case or more than one recursive step. But for now, this simple recursion is good enough to solve our factorial problem!
<blockquote>
If you'd like to learn more about recursion in Python, read our <a target="_blank" href="https://stackabuse.com/understanding-recursive-functions-with-python/">Guide to Understanding Recursion in Python</a>!
</blockquote>
<h2 id="conclusion">Conclusion</h2>
In this article, we covered how to calculate factorials using <code>for</code> and <code>while</code> loops. We also learned what recursion is, and how to calculate factorial using recursion.
If you've enjoyed the recursion and want to practice more, try calculating the Fibonacci sequence with recursion! And if you have any questions or thoughts about our article, feel free to share in the comment section.

In this article you will learn how to calculate the factorial of an integer with Python, using loops and recursion.

Calculate a Factorial With Python - Iterative and Recursive

In this guide, we'll take a look at the RegExp class and Regular Expressions in JavaScript, as well as the exec(), test(), match(), search() and replace() methods to pattern match Strings, with examples.

Guide to Regular Expressions and Matching Strings in JavaScript

Arpendu Kumar Garai

In this guide, we'll take a look at how to use the NATS JetStream library to asynchronously send messages in Java via the publish/subscribe pattern - to build distributed messaging systems and microservices.