In Python, there are two options/methods for running code:
<ul>
<li>Interactive mode</li>
<li>Script mode</li>
</ul>
In this article, we will see the difference between the modes and will also discuss the pros and cons of running scripts in both of these modes.
<h2 id="interactivemode">Interactive Mode</h2>
Interactive mode, also known as the <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop">REPL</a> provides us with a quick way of running blocks or a single line of Python code. The code executes via the Python shell, which comes with Python installation. Interactive mode is handy when you just want to execute basic Python commands or you are new to Python programming and just want to get your hands dirty with this beautiful language.
To access the Python shell, open the terminal of your operating system and then type &quot;python&quot;. Press the enter key and the Python shell will appear. This is the same Python executable you use to execute scripts, which comes installed by default on Mac and Unix-based operating systems.
<pre><code class="hljs">C:\Windows\system32&gt;python
Python 3.5.0 (v3.5.0:374f501f4567, Sep 13 2015, 02:27:37) [MSC v.1900 64 bit (AMD64)] on win32
Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.
&gt;&gt;&gt;
</code></pre>
The <code>&gt;&gt;&gt;</code> indicates that the Python shell is ready to execute and send your commands to the Python interpreter. The result is immediately displayed on the Python shell as soon as the Python interpreter interprets the command.
To run your Python statements, just type them and hit the enter key. You will get the results immediately, unlike in script mode. For example, to print the text &quot;Hello World&quot;, we can type the following:
<pre><code class="hljs">&gt;&gt;&gt; print(&quot;Hello World&quot;)
Hello World
&gt;&gt;&gt;
</code></pre>
Here are other examples:
<pre><code class="hljs">&gt;&gt;&gt; 10
10
&gt;&gt;&gt; print(5 * 20)
100
&gt;&gt;&gt; &quot;hi&quot; * 5
&#x27;hihihihihi&#x27;
&gt;&gt;&gt;
</code></pre>
We can also run multiple statements on the Python shell. A good example of this is when we need to declare many variables and access them later. This is demonstrated below:
<pre><code class="hljs">&gt;&gt;&gt; name = &quot;Nicholas&quot;
&gt;&gt;&gt; age = 26
&gt;&gt;&gt; course = &quot;Computer Science&quot;
&gt;&gt;&gt; print(&quot;My name is &quot; + name + &quot;, aged &quot; + str(age) + &quot;, taking &quot; + course)
</code></pre>
Output
<pre><code class="hljs">My name is Nicholas, aged 26, taking Computer Science
</code></pre>
Using the method demonstrated above, you can run multiple Python statements without having to create and save a script. You can also copy your code from another source then paste it on the Python shell.
Consider the following example:
<pre><code class="hljs">&gt;&gt;&gt; if 5 &gt; 10:
... print(&quot;5 is greater than 10&quot;)
... else:
... print(&quot;5 is less than 10&quot;)
...
5 is less than 10
&gt;&gt;&gt;
</code></pre>
The above example also demonstrates how we can run multiple Python statements in interactive mode. The two <code>print</code> statements have been indented using four spaces. Just like in script mode, if you don't indent properly you will get an error. Also, to get the output after the last <code>print</code> statement, you should press the enter key twice without typing anything.
<h3 id="gettinghelp">Getting Help</h3>
You can also get help with regards to a particular command in interactive mode. Just type the <code>help()</code> command on the shell and then hit the enter key. You will see the following:
<pre><code class="hljs">&gt;&gt;&gt; help()

Welcome to Python 3.5's help utility!

If this is your first time using Python, you should definitely check out
the tutorial on the Internet at http://docs.python.org/3.5/tutorial/.

Enter the name of any module, keyword, or topic to get help on writing
Python programs and using Python modules. To quit this help utility and
return to the interpreter, just type &quot;quit&quot;.

To get a list of available modules, keywords, or topics, type &quot;modules&quot;,
&quot;keywords&quot;, or &quot;topics&quot;. Each module also comes with a one-line summary
of what it does; to list the modules whose summaries contain a given word
such as &quot;spam&quot;, type &quot;modules spam&quot;.

help&gt;
</code></pre>
Now to find the help for a particular command, simple type that command, for instance, to find help for the <code>print</code> command, simply type <code>print</code> and hit the enter key. The result will look like this:
<pre><code class="hljs">Help on built-in function print in module builtins:

print(...)
 print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
 
 Prints the values to a stream, or to sys.stdout by default.
 Optional keyword arguments:
 file: a file-like object (stream); defaults to the current sys.stdout.
 sep: string inserted between values, default a space.
 end: string appended after the last value, default a newline.
 flush: whether to forcibly flush the stream.
</code></pre>
As shown in the above output, the help utility returned useful information regarding the print command including what the command does and what are some of the arguments that can be used with the command.
To exit help, type <code>q</code> for &quot;quit&quot; and then hit the enter key. You will be taken back to the Python shell.
<h3 id="prosandconsofinteractivemode">Pros and Cons of Interactive Mode</h3>
The following are the advantages of running your code in interactive mode:
<ol>
<li>Helpful when your script is extremely short and you want immediate results.</li>
<li>Faster as you only have to type a command and then press the enter key to get the results.</li>
<li>Good for beginners who need to understand Python basics.</li>
</ol>
The following are the disadvantages of running your code in the interactive mode:
<ol>
<li>Editing the code in interactive mode is hard as you have to move back to the previous commands or else you have to rewrite the whole command again.</li>
<li>It's very tedious to run long pieces of code.</li>
</ol>
Next, we will be discussing the script mode.
<h2 id="scriptmode">Script Mode</h2>
If you need to write a long piece of Python code or your Python script spans multiple files, interactive mode is not recommended. Script mode is the way to go in such cases. In script mode, You write your code in a text file then save it with a <code>.py</code> extension which stands for &quot;Python&quot;. Note that you can use any text editor for this, including Sublime, Atom, notepad++, etc.
If you are in the standard Python shell, you can click &quot;File&quot; then choose &quot;New&quot; or simply hit &quot;Ctrl + N&quot; on your keyboard to open a blank script in which you can write your code. You can then press &quot;Ctrl + S&quot; to save it.
After writing your code, you can run it by clicking &quot;Run&quot; then &quot;Run Module&quot; or simply press F5.
Let us create a new file from the Python shell and give it the name &quot;hello.py&quot;. We need to run the &quot;Hello World&quot; program. Add the following code to the file:
<pre><code class="hljs">print(&quot;Hello World&quot;)
</code></pre>
Click &quot;Run&quot; then choose &quot;Run Module&quot;. This will run the program:
Output
<pre><code class="hljs">Hello World
</code></pre>
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/python-programming-interactive-vs-script-mode-1.jpg">
Other than executing the program from the graphical user interface, we can do it from the terminal of the operating system. However, you must be aware of the path to the directory where you have saved the file.
Open the terminal of your operating system then navigate to the location of the file. Of course, you will use the &quot;cd (change directory)&quot; command for this.
Once you reach the directory with the file, you will need to invoke the Python interpreter on the file. This can be done using the following syntax:
<pre><code class="hljs">&gt; python &lt;filename&gt;
</code></pre>
To run the Python file from the terminal, you just have to type the <code>python</code> keyword followed by the name of the file. In our case, we need to run a file named &quot;hello.py&quot;. We need to type the following on the terminal of the operating system:
<pre><code class="hljs">&gt; python hello.py
Hello World
</code></pre>
If you want to get to the Python shell after getting the output, add the <code>-i</code> option to the command. This is demonstrated below:
<pre><code class="hljs">&gt; hello -i hello.py
Hello World
</code></pre>
The following example demonstrates how to execute the multiple lines of code using the Python script.
<pre><code class="hljs">name = &quot;Nicholas&quot;
age = 26
course = &quot;Computer Science&quot;
print(&quot;My name is&quot;, name, &quot;,aged&quot;, age, &quot;,taking&quot;, course)
</code></pre>
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/python-programming-interactive-vs-script-mode-2.jpg">
<h3 id="prosandconsofscriptmode">Pros and Cons of Script Mode</h3>
The following are the advantages of running your code in script mode:
<ol>
<li>It is easy to run large pieces of code.</li>
<li>Editing your script is easier in script mode.</li>
<li>Good for both beginners and experts.</li>
</ol>
The following are the disadvantages of using the script mode:
<ol>
<li>Can be tedious when you need to run only a single or a few lines of cod.</li>
<li>You must create and save a file before executing your code.</li>
</ol>
<h2 id="keydifferencesbetweeninteractiveandscriptmode">Key Differences Between Interactive and Script Mode</h2>
Here are the key differences between programming in interactive mode and programming in script mode:
<ol>
<li>In script mode, a file must be created and saved before executing the code to get results. In interactive mode, the result is returned immediately after pressing the enter key.</li>
<li>In script mode, you are provided with a direct way of editing your code. This is not possible in interactive mode.</li>
</ol>
<h2 id="conclusion">Conclusion</h2>
There are two modes through which we can create and run Python scripts: interactive mode and script mode. The interactive mode involves running your codes directly on the Python shell which can be accessed from the terminal of the operating system. In the script mode, you have to create a file, give it a name with a <code>.py</code> the extension then runs your code. The interactive mode is suitable when running a few lines of code. The script mode is recommended when you need to create large applications.

Nicholas Samuel

Python Programming in Interactive vs Script Mode

<h2 id="whatisajax">What is AJAX?</h2>
Asynchronous Javascript and XML (AJAX), is a way of communicating to a web server from a client-side application through the HTTP or HTTPS protocol.
Even though AJAX holds XML in the name, the way data is sent through requests or received doesn't have to be XML, but also plain text, or in most cases JSON, due to it being lighter and a part of JavaScript in and of itself.
<h3 id="whyisajaxuseful">Why is AJAX Useful?</h3>
<a rel="nofollow" target="_blank" href="https://vuejs.org/">Vue.js</a> is used as a front-end framework, and if you ever want to communicate with a server, to retrieve or store information to a database or perform some calculations on your data you will most likely need AJAX.
Even though <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Ajax_(programming)">AJAX</a> can be used by creating an <code>XMLHttpRequest</code> object, which will be available through the browser. There are certain packages that can help us communicate with our server.
Vue.js has an official package which is called <code>vue-resource</code> which works as an HTTP client, but the official documentation suggests using <a rel="nofollow" target="_blank" href="https://github.com/axios">Axios</a>.
<h3 id="installingaxiosandsettingupacomponent">Installing Axios and Setting up a Component</h3>
Axios is an HTTP client and it can be installed into our <code>package.json</code> dependencies via your package manager of choice, be it NPM or Yarn:
<pre><code class="hljs">$ npm install axios
OR
$ yarn add axios
</code></pre>
After the installation, we can set up a minimalistic test component for demonstration purposes:
<pre><code class="hljs">// Test.vue
&lt;template&gt;
 &lt;div/&gt;
&lt;/template&gt;

&lt;script&gt;
export default {
 data() {
 return {};
 };
}
&lt;/script&gt;
</code></pre>
<h3 id="usingaxiosinvuecomponents">Using Axios in Vue Components</h3>
Requests to a server over HTTP take a certain amount of time to return with a response, and, to make sure the information shown to the user is correct, promises will have to be used to make sure the data has returned before continuing with our code execution.
To use it in a component, we simply import the package and assign it to a variable:
<pre><code class="hljs">// Test.vue
&lt;script&gt;
import axios from &quot;axios&quot;;

export default {
 data() {
 return {};
 }
};
&lt;/script&gt;
</code></pre>
Generally, API calls are performed inside the mounted Vue lifecycle hook.
We are going to be using a mock JSON data service called <a href="https://jsonplaceholder.typicode.com/" rel="nofollow" target="_blank">JSONPlaceholder</a>. This is a simulation for what a back-end endpoint will look like when hitting a REST API:
<pre><code class="hljs">// Test.vue
&lt;script&gt;
import axios from &quot;axios&quot;;

export default {
 data() {
 return {};
 },
 mounted() {
 axios.get(&quot;https://jsonplaceholder.typicode.com/todos/&quot;)
 }
};
&lt;/script&gt;
</code></pre>
In the code example above, the component is rendered before the information from JSONPlaceholder has arrived. Therefore, the usage of promises will make sure we can handle the data and add it to our view.
<h3 id="handlingresponseswiththen">Handling Responses with then()</h3>
The <code>then()</code> function, lets us manipulate our promise and tell our code what we are going to do if/when the request was successful. We can, for example, with a callback function, check our response in the console:
<pre><code class="hljs">mounted() {
 axios.get(&quot;https://jsonplaceholder.typicode.com/todos/&quot;)
 .then(response =&gt; console.log(response))
}
</code></pre>
<img src="https://s3.amazonaws.com/stackabuse/media/sending-ajax-requests-with-vue-js-1.png" alt="browser_console_picture">
A response has been returned, and we can see it inside the browser's console, but, how do we show the user the todos list?
We should hold the todos list inside the data object for future referencing inside the DOM.
We will call it <code>todosList</code>, and we will copy the data property of the response object in an immutable way (so that we do not change the actual response object) by using the Javascript spread operator and just show the first 10 elements, using the slice array function, so that we do not load hundreds of todos:
<pre><code class="hljs">&lt;script&gt;
import axios from &quot;axios&quot;;

export default {
 data() {
 return {
 todosList: []
 };
 },
 mounted() {
 axios.get(&quot;https://jsonplaceholder.typicode.com/todos/&quot;)
 .then(response =&gt; {
 this.todosList = [...response.data].slice(0, 10)
 })
 }
};
&lt;/script&gt;
</code></pre>
<h2 id="handlingerrorswithcatch">Handling Errors with catch()</h2>
What happens if the request fails? The state of the application will have to be managed accordingly. For that we have the <code>catch()</code> function, which can be nested to our function stack:
<pre><code class="hljs">mounted() {
 axios.get(&quot;https://jsonplaceholder.typicode.com/todos/&quot;)
 .then(response =&gt; console.log(response))
 .catch(err =&gt; {
 // Manage the state of the application if the request 
 // has failed 
 })
}
</code></pre>
This way, we see the error being prompted, and we can do many things with it, like show an error message to the user as an alert or show a card saying &quot;No Todos Available&quot;. The possibilities are endless.
<h2 id="showingthetodos">Showing the Todos</h2>
Using the <code>v-for</code> Vue directive we can inject our todos inside the template and add some styling for visual purposes:
<pre><code class="hljs">&lt;template&gt;
 &lt;div&gt;
 &lt;ul 
 class=&quot;test-list&quot; 
 v-for=&quot;todo in todosList&quot; 
 :key=&quot;todo.id&quot;
 &gt;
 &lt;li class=&quot;test-list--item&quot;&gt;
 {{ todo.id }}
 &lt;/li&gt;
 &lt;/ul&gt;
 &lt;/div&gt;
&lt;/template&gt;

&lt;script&gt;
import axios from &quot;axios&quot;;

export default {
 data() {
 return {
 todosList: []
 };
 },
 mounted() {
 axios.get(&quot;https://jsonplaceholder.typicode.com/todos/&quot;)
 .then(response =&gt; {
 this.todosList = [...response.data].slice(0, 10)
 })
 .catch(err =&gt; {
 // Manage the state of the application if the request 
 // has failed 
 })
 }
};
&lt;/script&gt;

&lt;style&gt;
.test-list {
 font-family: Roboto;
 list-style: none;
 margin: 20px auto;
 width: 50%;
}

.test-list--item {
 border: 1px solid rgb(41, 41, 41);
 border-radius: 5px;
 text-align: center;
 display: block;
 box-shadow: 2px 2px rgba(138, 124, 124, 0.4);
}

.test-list--id {
 font-weight: 300;
 margin: 10px auto;
}

.test-list--title {
 font-weight: 500;
 margin: 20px auto;
 text-transform: capitalize;
}

.test-list--complete {
 font-weight: 600;
 margin: 10px auto;
 color: #56ca86;
}

.test-list--incomplete {
 font-weight: 600;
 margin: 10px auto;
 color: #ca5656;
}
&lt;/style&gt;
</code></pre>
If we check our browser, we will see something like this:
<img src="https://s3.amazonaws.com/stackabuse/media/sending-ajax-requests-with-vue-js-2.png" alt="http_request_sent">
Congratulations, we have just sent an HTTP request to an API and displayed the data to the user!
<h2 id="asyncawaitvspromises">Async/Await vs Promises</h2>
Async/Await is a relatively new language construct of JavaScript which makes our asynchronous code a lot cleaner.
Even though Async/Await calls will be transpiled to promises in the end, it conveys a different approach since we no longer need to setup callback functions for our code, we all know how much we hate those!
Our example code, using Async/Await would look something like the following, while adding some object destructuring magic to make our code look even better:
<pre><code class="hljs">// Test.vue
async mounted() {
 const url = &#x27;https://jsonplaceholder.typicode.com/todos/&#x27;
 const { data } = await axios.get(url)
 this.todosList = [...data].slice(0, 10)
}
</code></pre>
The mounted lifecycle hook is prefixed with the <code>async</code> keyword. This ensures that the hook returns a promise.
Within the hook, the <code>await</code> keyword makes the function called with it wait for its resolution to continue.
<h2 id="conclusion">Conclusion</h2>
AJAX is a key part of modern web development, and, even though it may look daunting at first, having it in your arsenal is a must.
The very nature of Vue.js makes you think about your code asynchronously so you can update your components properly, thus giving your users an awesome experience.
For more information on asynchronous code for Vue, you can check the <a rel="nofollow" target="_blank" href="https://vuejs.org/v2/cookbook/using-axios-to-consume-apis.html">Vue.js CookBook</a>.

Lucas Otero

Sending AJAX Requests in Vue.js

Robley Gori

PyTesseract: Simple Python Optical Character Recognition

While you can put simple projects in a single file, most Python development projects will require multiple files to keep them manageable. That means you need a way to import one file into another. However, many Pythonistas find importing files confusing. Fortunately, it is easy if you know the difference between the various Python import statements.
<h3 id="whatisimporting">What is Importing?</h3>
Importing refers to allowing a Python file or a Python module to access the script from another Python file or module. You can only use functions and properties your program can access. For instance, if you want to use mathematical functionalities, you must import the math package first. This is because you must define everything you want to use in Python before you use them.
For example, Python would give a <code>NameError</code> for the following code:
<pre><code class="hljs">myPi = math.pi
</code></pre>
This is because neither the <code>math</code> object nor its properties and methods are natively available to the language itself. To use the <code>math</code> object, you must import it first.
<pre><code class="hljs">import math

myPi = math.pi
print myPi
</code></pre>
The <code>import</code> statement adds the object to the current scope of your program.
<h3 id="howimportswork">How Imports Work</h3>
The <code>import</code> statements do a lot under the hood to import file or module. First, they look for your module or package in <code>sys.modules</code>, where Python stores your previously imported code. If Python cannot find the module there, it will then search through the Python Standard Library for it. If Python still cannot find the module, it will go through your entire storage space, starting with the current directory and the ones listed in your <code>system.path</code>. If the module is found in these places, it will add the module to your program, otherwise, it will give a <code>ModuleNotFoundError</code>.
<h4 id="importstatementsyntax">Import Statement Syntax</h4>
To import a module directly you just put the name of the module or package after the <code>import</code> keyword. Please note that this statement is case sensitive.
<pre><code class="hljs">import mymodule
</code></pre>
However, Python does offer a more sophisticated syntax for importing code. This second format includes the <code>from</code> keyword as well.
<pre><code class="hljs">from mypackage import mymodule
</code></pre>
In this format, you specify both the module or code you want along with where it is. You put the name of your code, module, or subpackage for <code>mymodule</code>, and its location for <code>mypackage</code>. Such an import statement is great if you only want to import some of the code from the mentioned package, and not the package itself.
You can even rename the module by including the <code>as</code> keyword.
<pre><code class="hljs">import mymodule as oMyFunction
</code></pre>
You can also use the asterisk (<code>*</code>) as a wild card. The following statement will import every function and property contained in the <code>math</code> package.
<pre><code class="hljs">from math import *
</code></pre>
Regardless of the syntax, you should always follow the recommended <a rel="nofollow" target="_blank" href="https://pep8.org/#imports">importing best practices</a>.
<h3 id="absoluteimports">Absolute Imports</h3>
Absolute imports include the entire path to your script, starting with the program's root folder. While you must separate each folder by a period, you can have it be as long as you need it.
The following are examples of absolute imports:
<pre><code class="hljs">from package1.firstmodule import firstmodule
import package1.secondmodule.myfunction
</code></pre>
<h4 id="absoluteimportadvantagesanddisadvantages">Absolute Import Advantages and Disadvantages</h4>
Unlike other languages, most Python developers prefer using absolute imports over their relative cousins. This is because absolute imports make it really clear what you are trying to do. The actual location of your files is right there in your code. In fact, you can use them anywhere in your code. They will just work.
Absolute imports can get quite long though. If your project has sub packages in sub packages in sub packages, your import statements can expand beyond a single line of code. When that happens, you are much better off using relative imports instead.
You also may discover an issue when you start your program using different startup files. The Python interpreter only declares the starting file's current folder as its <code>sys.path</code> package root. This is fine if you only load your program using files from the root folder. This is because <code>sys.path</code> will remain static throughout your script.
However, the situation changes when you start your program from a subfolder, or in any other situation where your <code>sys.path</code> may change. Then, your &quot;root folder&quot; is the subfolder. Because you cannot use implicit imports (as we will see below), any file outside the subfolder becomes inaccessible to your program.
You have two workarounds for this. You can either start your subfolder script as an imported module or you can append <code>sys.path</code> directly in your code.
For example:
<ul>
<li>Importing modules as run time: <code>python -m packA.a2</code></li>
<li>Append sys.path before importing your files:</li>
</ul>
<pre><code class="hljs">import os, sys
sys.path.append(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
from packA.subA import sa2
</code></pre>
<h3 id="relativeimports">Relative Imports</h3>
With relative imports, you only specify where your resources are relative to the current code file. You can do this either implicitly or explicitly, even though implicit relative imports were removed in Python 3.
As for the syntax, relative imports make use of dot notation. Single dots represent the directory of the current script. Two dots represent the parent folder. Thress dots mean the grandparent, and so forth. You might be familiar with this system if you use a UNIX-like operating system or the Windows console.
The following are examples of relative imports:
<ul>
<li>Explicit imports</li>
</ul>
<pre><code class="hljs">import other
from . import some_class
from .subA import sa1
</code></pre>
<ul>
<li>Implicit imports</li>
</ul>
<pre><code class="hljs">from .some_module import some_class
import some_function
import subA.sa1
</code></pre>
<h4 id="relativeimportsandtheiradvantagesanddisadvantages">Relative Imports and their Advantages and Disadvantages</h4>
Relative imports rarely grow as long as absolute imports. They can even turn a ridiculously long absolute statement into something as simple as:
<pre><code class="hljs">from ..my_sub_package.my_module import my_function
</code></pre>
However, they also hide the paths to your modules. This might be okay if you are the only developer, but it gets messy if you are a part of a development team where the actual directory structure can change.
<h3 id="whichimporttouse">Which Import to Use?</h3>
Unless you are working on a large project with several layers of sub-packages, you should always use absolute imports. That way, your code will be easily understood by anyone that looks at it, including yourself if you got back to it to update it later. Even if you do have long paths, you should still try to write your program to only use absolute statements to simplify your code and your life.
<h2 id="conclusion">Conclusion</h2>
Like any other modern programming language, Python allows you to import code from other files or modules. However, this can turn in to a confusing and error-prone process, unless you understand the concepts behind the import system.
In this article we looked at the various ways of importing code in to our Python programs, including absolute and relative imports. We also compared the pros and cons of each, which have their advantages in different use-cases.

Guest Contributor

Relative vs Absolute Imports in Python

Marcus Sanatan

Functional Programming in Python

Usman Malik

Dimitrije Stamenic

Linked Lists in Detail with Python Examples: Single Linked Lists

<h2 id="whatisapachespark">What is Apache Spark?</h2>
<a rel="nofollow" target="_blank" href="https://spark.apache.org">Apache Spark</a> is an in-memory distributed data processing engine that is used for processing and analytics of large data-sets. Spark presents a simple interface for the user to perform distributed computing on the entire cluster.
Spark does not have its own file systems, so it has to depend on the storage systems for data-processing. It can run on HDFS or cloud based file systems like <a rel="nofollow" target="_blank" href="https://aws.amazon.com/s3">Amazon S3</a> and <a rel="nofollow" target="_blank" href="https://azure.microsoft.com/en-us/services/storage/blobs/">Azure BLOB</a>.
Besides cloud based file systems it can also run with NoSQL databases like <a rel="nofollow" target="_blank" href="http://cassandra.apache.org/">Cassandra</a> and <a rel="nofollow" target="_blank" href="https://www.mongodb.com/">MongoDB</a>.
Spark jobs can be written in Java, Scala, Python, R, and SQL. It provides out of the box libraries for Machine Learning, Graph Processing, Streaming and SQL like data-processing. We will go into detail about each of these libraries later in the article.
The engine was developed at the University of California, Berkeley's AMPLab and was donated to Apache Software Foundation in 2013.
<h2 id="needforspark">Need for Spark</h2>
The traditional way of processing data on <a rel="nofollow" target="_blank" href="https://hadoop.apache.org/">Hadoop</a> is using its <a rel="nofollow" target="_blank" href="https://hadoop.apache.org/docs/r1.2.1/mapred_tutorial.html">MapReduce framework</a>. MapReduce involves a lot of disk usage and as such the processing is slower. As data analytics became more main-stream, the creators felt a need to speed up the processing by reducing the disk utilization during job runs.
Apache Spark addresses this issue by performing the computation in the main memory (RAM) of the worker nodes and does not store mid-step results of computation on disk.
Secondly, it doesn't actually load the data until it is required for computation. It converts the given set of commands into a Directed Acyclic Graph (<a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Directed_acyclic_graph">DAG</a>) and then executes it. This prevents the need to read data from the disk and writing back the output of each step as is the case with Hadoop MapReduce. As a result, Spark claims to process data at 100X faster than a corresponding job using MapReduce for in-memory computation jobs.
<h2 id="sparkarchitecture">Spark Architecture</h2>
<img src="https://s3.amazonaws.com/stackabuse/media/an-introduction-to-apache-spark-with-java-1.jpg" alt="Spark_Architecture"> 
Credit: <a rel="nofollow" target="_blank" href="https://spark.apache.org/">https://spark.apache.org/</a>
Spark Core uses a master-slave architecture. The Driver program runs in the master node and distributes the tasks to an Executor running on various slave nodes. The Executor runs on their own separate JVMs, which perform the tasks assigned to them in multiple threads.
Each Executor also has a cache associated with it. Caches can be in-memory as well as written to disk on the worker Node. The Executors execute the tasks and send the result back to the Driver.
The Driver communicates to the nodes in clusters using a Cluster Manager like the built-in cluster manager, <a rel="nofollow" target="_blank" href="http://mesos.apache.org">Mesos</a>, <a rel="nofollow" target="_blank" href="https://yarnpkg.com/en/">YARN</a>, etc. The batch programs we write get executed in the Driver Node.
<h2 id="simplesparkjobusingjava">Simple Spark Job Using Java</h2>
We have discussed a lot about Spark and its architecture, so now let's take a look at a simple Spark job which counts the sum of space-separated numbers from a given text file:
<pre><code class="hljs">32 23 45 67 2 5 7 9
12 45 68 73 83 24 1
12 27 51 34 22 14 31
...
</code></pre>
We will start off by importing the dependencies for Spark Core which contains the Spark processing engine. It has no further requirements as it can use the local file-system to read the data file and write the results:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.apache.spark&lt;/groupId&gt;
 &lt;artifactId&gt;spark-core_2.10&lt;/artifactId&gt;
 &lt;version&gt;2.2.3&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
With the core setup, let's proceed to write our Spark batch!
<pre><code class="hljs">public class CalculateFileSum {
 public static String SPACE_DELIMITER = &quot; &quot;;
 public static void main(String[] args) {

 SparkConf conf = new parkConf().setMaster(&quot;local[*]&quot;).setAppName(&quot;SparkFileSumApp&quot;);
 JavaSparkContext sc = new JavaSparkContext(conf);

 JavaRDD&lt;String&gt; input = sc.textFile(&quot;numbers.txt&quot;);
 JavaRDD&lt;String&gt; numberStrings = input.flatMap(s -&gt; Arrays.asList(s.split(SPACE_DELIMITER)).iterator());
 JavaRDD&lt;String&gt; validNumberString = numberStrings.filter(string -&gt; !string.isEmpty());
 JavaRDD&lt;Integer&gt; numbers = validNumberString.map(numberString -&gt; Integer.valueOf(numberString));
 int finalSum = numbers.reduce((x,y) -&gt; x+y);

 System.out.println(&quot;Final sum is: &quot; + finalSum);

 sc.close();
 }
}
</code></pre>
Running this piece of code should yield:
<pre><code class="hljs">Final sum is: 687
</code></pre>
The <code>JavaSparkContext</code> object we have created acts as a connection to the cluster. The Spark Context we have created here has been allocated all the available local processors, hence the <code>*</code>.
The most basic abstraction in Spark is <code>RDD</code>, which stands for Resilient Distributed Datasets. It is resilient and distributed since the data is replicated across the cluster and can be recovered if any of the nodes crash.
Another benefit of distributing data is that it can be processed in parallel thus promoting horizontal scaling. Another important feature of RDDs is that they are immutable. If we apply any action or transformation to a given RDD, the result is another set of RDDs.
In this example, we have read the words from the input file as <code>RDD</code>s and converted them into numbers. Then we have applied the <code>reduce</code> function on them to sum up the values of each of the RDDs before displaying them on the console.
<h2 id="introductiontosparklibraries">Introduction to Spark Libraries</h2>
Spark provides us with a number of built-in libraries which run on top of Spark Core.
<h3 id="sparksql">Spark SQL</h3>
<a rel="nofollow" target="_blank" href="https://spark.apache.org/sql/">Spark SQL</a> provides a SQL-like interface to perform processing of structured data. When the user executes an SQL query, internally a batch job is kicked-off by Spark SQL which manipulates the RDDs as per the query.
The benefit of this API is that those familiar with RDBMS-style querying find it easy to transition to Spark and write jobs in Spark.
<h3 id="sparkstreaming">Spark Streaming</h3>
<a rel="nofollow" target="_blank" href="https://spark.apache.org/streaming/">Spark Streaming</a> is suited for applications which deal in data flowing in real-time, like processing Twitter feeds.
Spark can integrate with <a rel="nofollow" target="_blank" href="https://kafka.apache.org">Apache Kafka</a> and other streaming tools to provide fault-tolerant and high-throughput processing capabilities for the streaming data.
<h3 id="sparkmllib">Spark MLlib</h3>
<a rel="nofollow" target="_blank" href="https://spark.apache.org/mllib/">MLlib</a> is short for Machine Learning Library which Spark provides. It includes the common learning algorithms like classification, recommendation, modeling, etc. which are used in Machine learning.
These algorithms can be used to train the model as per the underlying data. Due to the extremely fast data processing supported by Spark, the machine learning models can be trained in a relatively shorter period of time.
<h3 id="graphx">GraphX</h3>
As the name indicates, <a rel="nofollow" target="_blank" href="https://spark.apache.org/graphx/">GraphX</a> is the Spark API for processing graphs and performing graph-parallel computation.
The user can create graphs and perform operations like joining and transforming the graphs. As with MLlib, GraphX comes with built-in graph algorithms for page rank, triangle count, and more.
<h2 id="conclusion">Conclusion</h2>
Apache Spark is the platform of choice due to its blazing data processing speed, ease-of-use, and fault tolerant features.
In this article, we took a look at the architecture of Spark and what is the secret of its lightning-fast processing speed with the help of an example. We also took a look at the popular Spark Libraries and their features.

Chandan Singh

An Introduction to Apache Spark with Java

A lot of tools output data as comma-separated values (<a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Comma-separated_values">CSV</a>). It is a simple but common tabular data format of plain text that can easily be processed. Each line of the file represents a single record. A record consists of the same number of fields, or columns. Usually, the delimiter between the single fields is either a comma (<code>,</code>), a semi-colon (<code>;</code>), a space, or a tabulator.
One or more CSV files can be processed using the command-line tools <code>cut</code>, <code>join</code>, <code>head</code>, <code>comm</code>, <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Sed">sed</a>, and <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/AWK">AWK</a>. This approach works very well but may take you a while to find a proper solution based on these commands.
The following example shows how to calculate the total traveling distance for the trip listing shown below. The columns in the file <code>tracks.csv</code> are delimited by tabs, and the AWK script totalizes the values in the third column, only.
<pre><code class="hljs">$ cat tracks.csv 
Date Track Distance
1 Dec 2018 Paris-Metz 300
3 Dec 2018 Metz-Nancy 57
4 Dec 2018 Nancy-Vesoul 156
5 Dec 2018 Vesoul-Mulhouse 112
$ awk -F &#x27;\t+&#x27; &#x27;{ total += $3 } END {printf &quot;total: %d km\n&quot;, total}&#x27; tracks.csv
total: 625 km
</code></pre>
In contrast, Database Management Systems (DBMS) like MySQL, MariaDB, PostgreSQL, and SQLite store data in a non plain text format that can seldom be read in an open way. In order to extract data the statements have to be formulated in Structured Query Language (SQL), and evaluated by the DBMS.
The statement below shows how to extract the contents of the column Track from the table named track:
<pre><code class="hljs">SELECT Track FROM track
Paris-Metz
Metz-Nancy
Nancy-Vesoul
Vesoul-Mulhouse
(4 lines)
</code></pre>
Next we'll explain how to run SQL statements directly on CSV data. There are quite a few clever tools that make it possible to connect these worlds with each other.
<h2 id="q">q</h2>
The first tool is simply named <a rel="nofollow" target="_blank" href="https://harelba.github.io/q/">q</a>, and its name is actually derived from <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Star_Trek:_The_Q_Continuum">The Q Continuum</a> that is mentioned in the Star Trek series. The according Debian package for <code>q</code> is named <a rel="nofollow" target="_blank" href="https://packages.debian.org/stretch/python-q-text-as-data">python-q-text-as-data</a>. <code>q</code> accepts SQL statements, and allows direct execution on one or more CSV files.
Below you will see how to extract the first column named <code>Date</code> from the CSV file.
<pre><code class="hljs">$ q -H -t &quot;SELECT Date FROM tracks.csv&quot;
1 Dec 2018
3 Dec 2018
4 Dec 2018
5 Dec 2018
</code></pre>
The two flags used above have the following meaning:
<ul>
<li>
<code>-H</code> (<code>--skip-header</code>) : The first line of the data file contains a description of the columns (headers).
</li>
<li>
<code>-t</code>: The columns are tabular-separated.
</li>
</ul>
For the other flags we recommend you to have a look at the <code>q</code> <a rel="nofollow" target="_blank" href="https://github.com/harelba/q">usage page</a>.
In order to retrieve datasets based on conditions, you may write the following statement which extracts the distance value from all the datasets that store the date of 3 Dec 2018:
<pre><code class="hljs">$ q -H -t &quot;SELECT Distance FROM tracks.csv WHERE Date = &#x27;3 Dec 2018&#x27;&quot;
57
</code></pre>
<code>q</code> follows the SQL <a rel="nofollow" target="_blank" href="https://www.sqlite.org/lang.html">syntax used by SQLite</a>. According to the project website any standard SQL expressions, conditions (both <code>WHERE</code> and <code>HAVING</code>), <code>GROUP BY</code>, <code>ORDER BY</code>, etc. are allowed. In a <code>WHERE</code> clause, <code>JOIN</code>s and sub-queries are supported, too.
This also includes a number of functions like <code>ABS()</code>, <code>LENGTH()</code>, <code>LOWER()</code>, and <code>UPPER()</code> as well as date and time functions, aggregate functions, and JSON functions. In order to calculate the total of the single voyages use a statement as follows that demonstrates the <code>SUM()</code> function:
<pre><code class="hljs">$ q -H -t &quot;SELECT SUM(Distance) FROM tracks.csv&quot;
625
</code></pre>
The next example is borrowed from the <code>q</code> website, and demonstrates how to extract system information. It combines <code>ps</code> and <code>q</code> on a regular workstation in order to calculate the top 5 user ids with the largest number of owned processes, sorted in descending order.
<pre><code class="hljs">$ ps -ef | q -H &quot;SELECT UID,COUNT(*) cnt FROM - GROUP BY UID ORDER BY cnt DESC LIMIT 5&quot;
root 129
frank 68
postgres 6
www-data 5
avahi 2
</code></pre>
<code>q</code> also connects to the original <a target="_blank" href="/a-sqlite-tutorial-with-python/">Python SQLite</a> library. A similar functionality is provided by the <a rel="nofollow" target="_blank" href="https://pythonhosted.org/querycsv/">querycsv</a> Python module, that seems to be forked as the <a rel="nofollow" target="_blank" href="https://pypi.org/project/querycsv-redux/">querycsv-redux</a> project.
<h2 id="fsql">fsql</h2>
<code>fsql</code> is part of a Perl module named <a rel="nofollow" target="_blank" href="https://github.com/kshvmdn/fsql">fsql</a>. Currently, it is not available as a package for Debian or Ubuntu but from the Comprehensive Perl Archive Network (CPAN). In order to use <code>fsql</code> you may install the Perl module with its package dependencies using <a rel="nofollow" target="_blank" href="https://packages.debian.org/stretch/cpanminus">cpanm</a> as follows:
<pre><code class="hljs"># cpanm App::fsql
--&gt; Working on App::fsql
Fetching http://www.cpan.org/authors/id/P/PE/PERLANCAR/App-fsql-0.230.tar.gz ... OK
Configuring App-fsql-0.230 ... OK
==&gt; Found dependencies: DBD::CSV, JSON::MaybeXS, Data::Format::Pretty::YAML, Data::Format::Pretty::Console, YAML::XS, Data::Format::Pretty::JSON, File::chdir, Data::Format::Pretty::Perl, Text::LTSV, Perinci::Result::Util, File::Slurper
--&gt; Working on DBD::CSV
Fetching http://www.cpan.org/authors/id/H/HM/HMBRAND/DBD-CSV-0.54.tgz ... OK
Configuring DBD-CSV-0.54 ... OK
==&gt; Found dependencies: SQL::Statement
--&gt; Working on SQL::Statement
Fetching http://www.cpan.org/authors/id/R/RE/REHSACK/SQL-Statement-1.412.tar.gz ... OK
Configuring SQL-Statement-1.412 ... OK

[...]

Building and testing App-fsql-0.230 ... OK
Successfully installed App-fsql-0.230
95 distributions installed
</code></pre>
As explained on the <code>fsql</code> project page the tool lets you perform SQL queries against one or several &quot;flat&quot; files of various formats such as plain text, CSV, and JSON.
The example below demonstrates how to extract all the voyages that have a distance of more than 100 km. The data is provided from <code>stdin</code> using <code>cat</code>, and piped to <code>fsql</code>, then:
<pre><code class="hljs">$ cat tracks.csv | fsql &#x27;SELECT Date,Track,Distance FROM stdin WHERE Distance &gt; 100&#x27;
Date Track Distance
&quot;1 Dec 2018&quot; Paris-Metz 300
&quot;4 Dec 2018&quot; Nancy-Vesoul 156
&quot;5 Dec 2018&quot; Vesoul-Mulhouse 112
</code></pre>
So far, <code>fsql</code> produced a line-based output that is common for databases. Using the output parameter <code>-f</code> plus the desired output format, it can do much more. Among others, <code>fsql</code> supports comma-separated values (<code>csv</code>), tabular-separated values (<code>tsv</code>), Perl (<code>perl</code>), JavaScript Object Notation (JSON) (<code>json</code>), and YAML Ain't Markup Language (YAML) (<code>yaml</code>).
The example below outputs the query result as a JSON array:
<pre><code class="hljs">$ cat tracks.csv | fsql &#x27;SELECT Date,Track,Distance FROM stdin WHERE Distance &gt; 60&#x27; -f json
[
 [
 &quot;1 Dec 2018&quot;,
 &quot;Paris-Metz&quot;,
 &quot;300&quot;
 ],
 [
 &quot;4 Dec 2018&quot;,
 &quot;Nancy-Vesoul&quot;,
 &quot;156&quot;
 ],
 [
 &quot;5 Dec 2018&quot;,
 &quot;Vesoul-Mulhouse&quot;,
 &quot;112&quot;
 ]
]
</code></pre>
Using the option <code>-f yaml</code> the output is formatted in YAML style:
<pre><code class="hljs">$ cat tracks.csv | fsql &#x27;SELECT sum(Distance) FROM stdin&#x27; -f yaml
---
-
 - 625
</code></pre>
<h2 id="miller">Miller</h2>
Asking long-term Linux experts about <a rel="nofollow" target="_blank" href="https://johnkerl.org/miller/doc/index.html">Miller</a> may result in a bit of a surprise as it is just less known than other options. Miller aims to combine the functionality of several text tools such as <code>cat</code>, <code>grep</code>, <code>sed</code>, <code>awk</code>, <code>join</code>, and <code>sort</code>.
The screen-shot below uses the <code>cut</code> subcommand, and shows how to extract the second column that contains the routes. This call is similar to the SQL query <code>SELECT Track from track</code>.
<img alt="miller cut" class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/running-sql-on-csv-data-data-conversion-extraction-1.png">
<h2 id="others">Others</h2>
The list of helpful tools can be extended for a while. D. Bohdan maintains a rather <a rel="nofollow" target="_blank" href="https://github.com/dbohdan/structured-text-tools/">comprehensive list</a>. Among others this contains <a rel="nofollow" target="_blank" href="http://tobimensch.github.io/termsql/">termsql</a>, <a rel="nofollow" target="_blank" href="https://stedolan.github.io/jq/">jq</a>, as well as SPAWK which is an <a rel="nofollow" target="_blank" href="http://www.awklang.org/spawk/?child">SQL Powered AWK</a>.
Funny stuff, which we will deal with in more detail in one of the next articles.
<h2 id="acknowledgements">Acknowledgements</h2>
The author would like to thank Axel Beckert for his critical comments while preparing this article.

Frank Hofmann

Running SQL on CSV Data: Data Conversion and Extraction

<h2 id="introduction">Introduction</h2>
When we think about repeating a task, we usually think about the <code>for</code> and <code>while</code> loops. These constructs allow us to perform iteration over a list, collection, etc.
However, there's another form of repeating a task, in a slightly different manner. By calling a function within itself, to solve a smaller instance of the same problem, we're performing recursion.
These functions call themselves until the problem is solved, practically dividing the initial problem to a lot of smaller instances of itself – like, for example, taking small bites of a larger piece of food.
The end goal is to eat the entire plate of hot pockets, you do this by taking a bite over and over. Each bite is a recursive action, after which you undertake the same action the next time. You do this for every bite, evaluating that you should take another one to reach the goal, until there are no hot pockets left on your plate.
<h2 id="whatisrecursion">What is Recursion?</h2>
As stated in the introduction, <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Recursion">recursion</a> involves a process calling itself in the definition. A recursive function generally has two components:
<ul>
<li>The base case which is a condition that determines when the recursive function should stop</li>
<li>The call to itself</li>
</ul>
Let's take a look at a small example to demonstrate both components:
<pre><code class="hljs"># Assume that remaining is a positive integer
def hi_recursive(remaining):
 # The base case
 if remaining == 0:
 return
 print(&#x27;hi&#x27;)

 # Call to function, with a reduced remaining count
 hi_recursive(remaining - 1)
</code></pre>
The base case for us is if the <code>remaining</code> variable is equal to <code>0</code> i.e. how many remaining <code>hi</code> strings we must print. The function simply returns.
After the print statement, we call <code>hi_recursive</code> again but with a reduced remaining value. This is important! If we do not decrease the value of <code>remaining</code> the function will run indefinitely. Generally, when a recursive function calls itself the parameters are changed to be closer to the base case.
Let's visualize how it works when we call <code>hi_recursive(3)</code>:
<img src="https://s3.amazonaws.com/stackabuse/media/understanding-recursion-with-python-1.jpg" alt="hi_recursive example">
After the function prints <code>hi</code>, it calls itself with a lower value for <code>remaining</code> until it reaches <code>0</code>. At zero, the function returns to where it was called in <code>hi_recursive(1)</code>, which returns to where it was called in <code>hi_recursive(2)</code> and that ultimately returns to where it was called in <code>hi_recursive(3)</code>.
<h2 id="whynotusealoop">Why not use a Loop?</h2>
All traversal can be handled with loops. Even so, some problems are often easier solved with recursion rather than iteration. A common use case for recursion is tree traversal:
<blockquote>
Traversing through nodes and leaves of a tree is usually easier to think about when using recursion. Even though loops and recursion both traverse the tree, they have different purposes – loops are meant to repeat a task whereas recursion is meant to break down a large task into smaller tasks.
</blockquote>
Recursion with trees for example fork well because we can process the entire tree by processing smaller parts of the tree individually.
<h2 id="examples">Examples</h2>
The best way to get comfortable with recursion, or any programming concept, is to practice it. Creating recursive functions are straightforward: be sure to include your base case and call the function such that it gets closer to the base case.
<h3 id="sumofalist">Sum of a List</h3>
Python includes a <code>sum</code> function for lists. The default Python implementation, CPython, uses an indefinite for-loop in C to create those functions (source code <a rel="nofollow" target="_blank" href="https://github.com/python/cpython/blob/master/Python/bltinmodule.c#L2285">here</a> for those interested). Let's see how to do it with recursion:
<pre><code class="hljs">def sum_recursive(nums):
 if len(nums) == 0:
 return 0

 last_num = nums.pop()
 return last_num + sum_recursive(nums)
</code></pre>
The base case is the empty list - the best <code>sum</code> for that is <code>0</code>. Once we handle our base case, we remove the last item of the list. We finally call the <code>sum_recursive</code> function with the reduced list, and we add the number we pulled out into the total.
In a Python interpreter <code>sum([10, 5, 2])</code> and <code>sum_recursive([10, 5, 2])</code> should both give you <code>17</code>.
<h3 id="factorialnumbers">Factorial Numbers</h3>
You may recall that a <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Factorial">factorial</a> of a positive integer, is the product of all integers preceding it. The following example would make it clearer:
<pre><code class="hljs">5! = 5 x 4 x 3 x 2 x 1 = 120
</code></pre>
The exclamation mark denotes a factorial, and we see that we multiply <code>5</code> by the product of all the integers from <code>4</code> till <code>1</code>. What if someone enters <code>0</code>? It's widely understood and proven that <code>0! = 1</code>. Now let's create a function like below:
<pre><code class="hljs">def factorial(n):
 if n == 0 or n == 1:
 return 1
 return n * factorial(n - 1)
</code></pre>
We cater for the cases where <code>1</code> or <code>0</code> is entered, and otherwise we multiply the current number by the factorial of the number decreased by <code>1</code>.
A simple verification in your Python interpreter would show that <code>factorial(5)</code> gives you <code>120</code>.
<h3 id="fibonaccisequence">Fibonacci Sequence</h3>
A <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Fibonacci_number">Fibonacci sequence</a> is one where each number is the sum of the proceeding two numbers. This sequence makes an assumption that Fibonacci numbers for 0 and 1 are also 0 and 1. The Fibonacci equivalent for 2 would therefore be 1.
Let's see the sequence and their corresponding natural numbers:
<pre><code class="hljs"> Integers: 0, 1, 2, 3, 4, 5, 6, 7
 Fibonacci: 0, 1, 1, 2, 3, 5, 8, 13
</code></pre>
We can easily code a function in Python to determine the fibonacci equivalent for any positive integer using recursion:
<pre><code class="hljs">def fibonacci(n):
 if n == 0:
 return 0
 if n == 1:
 return 1
 return fibonacci(n - 1) + fibonacci(n - 2)
</code></pre>
You can verify it works as expected by checking that <code>fibonacci(6)</code> equals <code>8</code>.
Now I'd like you to consider another implementation of this function that uses a for loop:
<pre><code class="hljs">def fibonacci_iterative(n):
 if n &lt;= 1:
 return n

 a = 0
 b = 1
 for i in range(n):
 temp = a
 a = b
 b = b + temp
 return a
</code></pre>
If the integer is less than or equal to 1, then return it. Now that our base case is handled. We continuously add the first number with the second one by storing the first number in a <code>temp</code> variable before we update it.
The output is the same as the first <code>fibonacci()</code> function. This version is faster than the recursive one, as Python implementations are not optimized for recursion but excels with imperative programming. The solution however, is not as easily readable as our first attempt. There lies one of recursion's greatest strengths: elegance. Some programming solutions are most naturally solved using recursion.
<h2 id="conclusion">Conclusion</h2>
Recursion allows us to break a large task down to smaller tasks by repeatedly calling itself. A recursive function requires a base case to stop execution, and the call to itself which gradually leads the function to the base case. It's commonly used in trees, but other functions can be written with recursion to provide elegant solutions.