Vuk Skobalj

Guide to Spring Data JPA

Mateusz Dobrychlop

Python GUI Development with Tkinter: Part 2

Usman Malik

Object Oriented Programming in Python

<h2 id="introduction">Introduction</h2>
In this article, we'll dive into the <a rel="nofollow" target="_blank" href="https://swagger.io/">Swagger framework</a>. We'll use Swagger2 to design, build, and document a <a rel="nofollow" target="_blank" href="https://spring.io/projects/spring-boot">Spring Boot</a> RESTful API and <a rel="nofollow" target="_blank" href="https://swagger.io/tools/swagger-ui/">Swagger UI</a> to observe our endpoints and test them.
<h2 id="whatisswagger">What is Swagger?</h2>
Swagger is the most widely used tool for building APIs compliant to the <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/OpenAPI_Specification">OpenAPI Specification</a> (OAS).
Swagger itself is a set of open-source tools built around the OAS that can help you design, build, document, and generate the REST API documents for RESTful web services.
The most prominent Swagger tools are:
<ul>
<li><a rel="nofollow" target="_blank" href="http://editor.swagger.io/">Swagger Editor</a> – browser-based editor where you can write OpenAPI specs</li>
<li><a rel="nofollow" target="_blank" href="https://swagger.io/tools/swagger-ui/">Swagger UI</a> – renders OpenAPI specs as interactive API documentation</li>
<li><a rel="nofollow" target="_blank" href="https://github.com/swagger-api/swagger-codegen">Swagger Codegen</a> – generates server stubs and client libraries from an OpenAPI spec</li>
</ul>
Swagger2 is an extension of Swagger into new technologies and protocols beyond HTTP.
<h2 id="buildinganapplication">Building an Application</h2>
Integrating Swagger2 into a Spring Boot application is quite fast and easy with the help of some tools we already use day-in and day-out.
The simplest way to start with a skeleton Spring Boot project, as always, is using &lt;a rel=”nofollow” target=”_blank” href=” https://start.spring.io/”&gt;Spring Initializr</a>.
Select your preferred version of Spring Boot and generate it as a Maven project and you're all set!
To enable Swagger2 itself, you'll need to add a couple of dependencies to your <code>pom.xml</code> file:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;io.springfox&lt;/groupId&gt;
 &lt;artifactId&gt;springfox-swagger2&lt;/artifactId&gt;
 &lt;version&gt;${version}&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
With our project fully set-up and our dependencies in check, we can go ahead and create a simple REST endpoint which we'll expose in the documentation later on:
<pre><code class="hljs">@RestController
@RequestMapping(&quot;/v1/hello&quot;)
public class HelloResource {

 @GetMapping
 public String hello() {
 return &quot;Hello World&quot;;
 }

 @PostMapping(&quot;/post&quot;)
 public String helloPost(@RequestBody String hello) {
 return hello;
 }

 @PutMapping(&quot;/put&quot;)
 public String helloPut(@RequestBody String hello) {
 return hello;
 }
}
</code></pre>
After this, let's go ahead and create one more REST endpoint - <code>UserResource</code>:
<pre><code class="hljs">@RestController
@RequestMapping(&quot;/v1/user&quot;)
public class UserResource {

@GetMapping
public List&lt;User&gt; getUsers() {
 return Arrays.asList(
 new User(&quot;John&quot;, 3000),
 new User(&quot;Kevin&quot;, 2000)
 );
}

@GetMapping(&quot;/{userName}&quot;)
public User getUser(@PathVariable(&quot;userName&quot;) String userName) {
 return new User(userName, 2000);
}
</code></pre>
Both of these classes rely on the <code>User</code> model:
<pre><code class="hljs">private class User {

 private String userName;
 private Integer salary;

 // constructor, getters and setters
}
</code></pre>
<h3 id="enablingswagger2">Enabling Swagger2</h3>
Now is about the time to enable Swagger2 in our application by defining a configuration class for it.
The configuration class needs to be annotated with <code>@Configuration</code> - the standard Spring annotation, and <code>@EnableSwagger2</code> annotations to enable the framework for your Spring Boot application.
The order of these annotations isn't important:
<pre><code class="hljs">@EnableSwagger2
@Configuration
public class Swagger2Config {

 @Bean
 public Docket productApi() {
 return new Docket(DocumentationType.SWAGGER_2)
 .select()
 .apis(RequestHandlerSelectors.basePackage(&quot;com.demo.resource&quot;))
 .paths(regex(&quot;/v1.*&quot;))
 .build();
 }
}
</code></pre>
We'll define a Bean named <code>Docket</code> in the configuration class for this purpose.
<code>Docket</code> is a builder which is intended to be the primary interface into the <code>swagger-springmvc</code> framework. It provides sensible defaults and convenience methods for configuration.
After the Docket bean is defined, calling its <code>select()</code> method returns an instance of <code>ApiSelectorBuilder</code>, which provides control over the endpoints exposed by Swagger.
We can define a base package for our REST API classes as well if we wish to, using <code>RequestHandlerSelectors.basePackage()</code>. It will scan the base package and create APIs for all of the classes within it.
On the other hand, we can use <code>RequestHandlerSelectors.any()</code> to generate documentation for all packages.
In our case, it's the <code>com.demo.resource</code> package, where we defined the <code>HelloResource</code> and <code>UserResource</code> classes.
The <code>paths()</code> method further defines which paths in our APIs we want to create documentation for. All of our endpoints have &quot;/v1&quot;, so in our case it includes all of the endpoints. However, this may not always be the case.
If you'd wish to include all endpoints - you can easily do so by using <code>PathSelectors.any()</code>.
<h3 id="swaggerui">Swagger UI</h3>
Let's use Swagger UI to observe all of our REST endpoints that Swagger created.
To utilize Swagger UI, we need to add a dependency for it to our <code>pom.xml</code> file:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;io.springfox&lt;/groupId&gt;
 &lt;artifactId&gt;springfox-swagger-ui&lt;/artifactId&gt;
 &lt;version&gt;${version}&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
Now, navigate to <code>localhost:8080/swagger-ui.html</code>. This is the URL where we can observe all rest endpoints which Swagger created:
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/java-rest-api-documentation-swagger2-1.png">
As you can see, both of our endpoints are here - hello-resource and user-resource, with their respective methods inside. The method names are defined on the right, as you can see.
We can use this UI to test out our endpoints:
<ul>
<li>Click on <code>HelloResource</code> and expand <code>GET/v1/hello</code></li>
<li>Click the rest call <code>Try it out</code> button</li>
</ul>
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/java-rest-api-documentation-swagger2-2.png">
We'll be greeted with the Response Body &quot;Hello World&quot; and Response Code 200 which means that it's working as intended.
Same as for the <code>GET/v1/user</code> from the class <code>UserResource</code>:
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/java-rest-api-documentation-swagger2-3.png">
We'll be greeted with the information relevant to the user we created before.
<h2 id="customizingswagger2">Customizing Swagger2</h2>
Sometimes, companies and teams need to customize Swagger2's behavior, adding custom messages and operations to tailor the use of the framework to their own needs.
To do this, we need to override the meta information of the framework with <code>ApiInfo</code>.
The constructor of <code>ApiInfo</code> expects:
<ul>
<li><code>String title</code></li>
<li><code>String description</code></li>
<li><code>String version</code></li>
<li><code>String termsOfServiceUrl </code></li>
<li><code>new Contact(contactName, &quot;&quot;, &quot;&quot;)</code></li>
<li><code>String license</code></li>
<li><code>String licenseUrl</code></li>
</ul>
If you don't want to define any of these, you can just input <code>null</code> and that field will not be shown on the UI:
<pre><code class="hljs">@EnableSwagger2
@Configuration
public class SwaggerConfig {

 @Bean
 public Docket productApi() {
 return new Docket(DocumentationType.SWAGGER_2)
 .select()
 .apis(RequestHandlerSelectors.basePackage(&quot;com.demo.resource&quot;))
 .paths(regex(&quot;/v1.*&quot;))
 .build()
 .apiInfo(metaInfo());
 }

 private ApiInfo metaInfo() {

 ApiInfo apiInfo = new ApiInfo(
 &quot;Spring Boot Swagger2 Example API&quot;,
 null,
 &quot;1.0&quot;,
 &quot;Terms of Service&quot;,
 new Contact(&quot;Your Name or Team&quot;, null,
 null),
 &quot;Apache License Version 2.0&quot;,
 &quot;https://www.apache.org/licenses/&quot;
 );

 return apiInfo;
 }
}
</code></pre>
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/java-rest-api-documentation-swagger2-4.png">
We can override method names with annotations.
The <code>@ApiOperation</code> annotation allows us to override the endpoint and its response type. Swagger2 also allows overriding the default response messages of <code>HTTP</code> methods.
You can use the <code>@ApiResponse</code> annotation to document other responses, in addition to the regular <code>HTTP 200 OK</code>:
<pre><code class="hljs">@ApiOperation(value = &quot;Returns Hello World&quot;, description = &quot;shows hello world&quot;)
@ApiResponses(value = {
 @ApiResponse(code = 200, message = &quot;The request has succeeded or (your message)&quot;),
 @ApiResponse(code = 401, message = &quot;The request requires user authentication or (your message)&quot;),
 @ApiResponse(code = 403, message = &quot;Accessing the resource you were trying to reach is forbidden or (your message)&quot;),
 @ApiResponse(code = 404, message = &quot;The server has not found anything matching the Request-URI or (your message)&quot;)
</code></pre>
Let's take a look at the UI:
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/java-rest-api-documentation-swagger2-5.png">
Upon expanding <code>hello-resource</code> we can see that the right side of the documentation got updated. Also, the response messages updated with code that we provided and return type from the <code>@Api</code> annotation on class level.
<h3 id="modelproperties">Model Properties</h3>
Swagger2 provides us with a set of annotations to manipulate models with a lot of control:
<ul>
<li>@ApiModel - Allows us to manipulate metadata of a model</li>
<li>@ApiModelProperty - Allows us control over Swagger-specific definitions and operations (allowed values, notes, filtering)</li>
</ul>
We'll need to update our <code>UserResource</code> controller with the <code>@Api</code> annotation on the class level.
In Swagger2, this annotation is used to apply definitions to all operations defined under it, unlike its usage in previous versions, where it declared resources:
<pre><code class="hljs">@RestController
@RequestMapping(&quot;/v1/user&quot;)
@Api(value = &quot;User Resource REST Endpoint&quot;, description = &quot;Shows the user info&quot;)
public class UserResource {

 @GetMapping
 public List&lt;User&gt; getUsers() {

 return Arrays.asList(
 new User(&quot;John&quot;, 2000),
 new User(&quot;Kevin&quot;, 1000)
 );
 }

 @GetMapping(&quot;/{userName}&quot;)
 public User getUser(@PathVariable(&quot;userName&quot;) String userName) {
 return new User(userName, 1000);
 }
</code></pre>
After updating the API, let's update the model too:
<pre><code class="hljs">@ApiModel
private class User {

 @ApiModelProperty(notes = &quot;name of the user&quot;)
 private String userName;

 @ApiModelProperty(notes = &quot;salary of the user&quot;)
 private Integer salary;

 @ApiModelProperty(allowableValues = &quot;active, inactive, banned&quot;)
 private String status;

 // constructor, getters and setters
}
</code></pre>
There's a wide range of things you can define using <code>@ApiModelProperty</code>. For more information and a list of methods, visit <a rel="nofollow" target="_blank" href="http://docs.swagger.io/swagger-core/v1.5.X/apidocs/index.html?io/swagger/annotations/ApiModelProperty.html">the official documentation</a>.
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/java-rest-api-documentation-swagger2-6.png">
Expanding <code>GET/v1/user</code> then clicking on the <code>Model</code> property, we can notice the descriptions on each field.
&quot;Example Value&quot; shows just default values.
<h2 id="conclusion">Conclusion</h2>
Each day, companies and individuals are starting to use Swagger as their tool of choice for exposing REST APIs to third parties.
Utilizing Swagger's tools, you can generate code based on the documentation of an API, as well as create beautiful, interactive documentation. This both saves time and effort and offers a standard for people to work with.

Java REST API Documentation with Swagger2

<h2 id="whatisvim">What is Vim?</h2>
Vim is a powerful text editor that belongs to one of the default components on every Linux distribution, as well as Mac OS X. Vim follows its own concept of usage, causing the community to divide into strong supporters and vehement opponents that are in favor of other editors like Emacs. (By the way, that's very nice in winter in order to see the two enthusiastic teams having an extensive snowball fight together).
Vim can be individualized and extended using additional plugins in order to adjust the tool to your specific needs. In this article we highlight a selection of extensions and discuss a useful setup to improve software development with Python.
<h2 id="autocompletion">Auto-Completion</h2>
Vim is already equipped with an auto-completion feature. This works well but is limited to words that already exist in the current text buffer. In insert mode, using the key combination <code>CTRL+N</code> you get the next word in the current buffer, and <code>CTRL+P</code> the last one. In either way a menu with words pops up from which you choose the word to be pasted in the text at the current cursor position of the document.
<img class="img-responsive" alt="A selection of words to choose from" src="https://s3.amazonaws.com/stackabuse/media/vim-for-python-development-1.png">
This is already quite cool. Luckily, the same feature exists for entire lines of text. In insert mode press <code>CTRL+X</code> first, followed by <code>CTRL+L</code>. A menu pops up with similar lines from which you choose the line you would like to be pasted in the text at the current cursor position of the document.
<img class="img-responsive" alt="A selection of lines to choose from" src="https://s3.amazonaws.com/stackabuse/media/vim-for-python-development-2.png">
To develop effectively in Python, Vim contains a standard module named <a rel="nofollow" target="_blank" href="https://www.vim.org/scripts/script.php?script_id=1542">pythoncomplete</a> (Python Omni Completion). In order to activate this plugin add the following two lines to your Vim configuration file <code>.vimrc</code>:
<pre><code class="hljs">filetype plugin on
set omnifunc=syntaxcomplete#Complete
</code></pre>
Then, in the Vim editor window the completion works in insert mode based on the key combination <code>CTRL+X</code> followed by <code>CTRL+O</code>. A sub-menu pops up that offers you Python functions and keywords to be used. The menu entries are based on Python module descriptions (&quot;docstrings&quot;). The example below shows the <code>abs()</code> function with additional help on top of the vim editor screen.
<img class="img-responsive" alt="A selection of keywords to choose from" src="https://s3.amazonaws.com/stackabuse/media/vim-for-python-development-3.png">
The next plugin I'd like to discuss is named <a rel="nofollow" target="_blank" href="https://github.com/davidhalter/jedi-vim">Jedi-Vim</a>. It connects Vim with the <a rel="nofollow" target="_blank" href="https://github.com/davidhalter/jedi">Jedi</a> auto-completion library.
Having installed the according package on your Debian GNU/Linux system it needs an additional step to make Jedi-Vim work. The plugin has to be activated using the Vim plugin manager as follows:
<pre><code class="hljs">$ vim-addons install python-jedi
Info: installing removed addon &#x27;python-jedi&#x27; to /home/frank/.vim
Info: Rebuilding tags since documentation has been modified ...
Processing /home/frank/.vim/doc/
Info: done.
</code></pre>
Next, check the status of the plugin:
<pre><code class="hljs">$ vim-addons status python-jedi
# Name User Status System Status 
python-jedi installed removed
</code></pre>
Now the plugin is activated and you can use it in Vim while programming. As soon as you either type a dot or press <code>CTRL+Space</code> the menu opens and shows you method and operator names that could fit. The image below shows the according entries from the <code>csv</code> module. As soon as you choose an item from the menu it will be pasted into your source code.
<img class="img-responsive" alt="Jedi-Vim in action" src="https://s3.amazonaws.com/stackabuse/media/vim-for-python-development-4.png">
An interactive plugin is <a rel="nofollow" target="_blank" href="https://github.com/valloric/youcompleteme">youcompleteme</a>. It describes itself as &quot;a fast, as-you-type, fuzzy-search code completion engine for Vim&quot;. For Python 2 and 3, the automatic completion is based on Jedi as well. Among other programming languages it also supports C#, Go, Rust, and Java.
Provided in a Git repository, the setup requires additional steps in order to use it. The package on Debian GNU/Linux comes with a compiled version, and after installing the package via <code>apt-get</code> the <a rel="nofollow" target="_blank" href="https://val.markovic.io/articles/youcompleteme-a-fast-as-you-type-fuzzy-search-code-completion-engine-for-vim">following steps</a> will <a rel="nofollow" target="_blank" href="https://stackoverflow.com/questions/33982603/vim-youcompleteme-not-working-in-debian-jessie/34032417">make it work</a>. First, enable the package using the Vim-addon-manager (<code>vam</code>) or the command <code>vim-addons</code>:
<pre><code class="hljs">$ vim-addons install youcompleteme
Info: installing removed addon &#x27;youcompleteme&#x27; to /home/frank/.vim
Info: Rebuilding tags since documentation has been modified ...
Processing /home/frank/.vim/doc/
Info: done.
</code></pre>
Next, check the status of the plugin. The output below shows you that the plugin is successfully installed for you as a regular user:
<pre><code class="hljs">$ vim-addons status youcompleteme
# Name User Status System Status 
youcompleteme installed removed
</code></pre>
Third, copy the default <code>ycm_extra_conf.py</code> file from the examples directory to your <code>~/.vim/</code> folder as follows:
<pre><code class="hljs">$ cp -v /usr/share/doc/vim-youcompleteme/examples/ycm_extra_conf.py .ycm_extra_conf.py
&quot;/usr/share/doc/vim-youcompleteme/examples/ycm_extra_conf.py&quot; -&gt; &quot;.ycm_extra_conf.py&quot;
</code></pre>
The final step is to add the following two lines to your <code>.vimrc</code> file:
<pre><code class="hljs">&quot; youcompleteme
let g:ycm_global_ycm_extra_conf = &quot;~/.vim/.ycm_extra_conf.py&quot;
</code></pre>
The first line is a comment that could be omitted, and the second line defines the configuration file for the <code>youcompleteme</code> plugin. Et voilà! - now Vim accepts automated completion of code. When you see a useful completion string being offered, press the <code>TAB</code> key to accept it. This inserts the completion string at the current position. Repeated presses of the <code>TAB</code> key cycle through the offered completions.
<img class="img-responsive" alt="The plugin youcompleteme in action" src="https://s3.amazonaws.com/stackabuse/media/vim-for-python-development-5.png">
<h2 id="syntaxhighlighting">Syntax Highlighting</h2>
Vim already comes with syntax highlighting for a huge number of programming languages that includes Python. There are three plugins that help to improve it - one is called <a rel="nofollow" target="_blank" href="https://github.com/vim-python/python-syntax">python-syntax</a>, the other one is <a rel="nofollow" target="_blank" href="https://vimawesome.com/plugin/python-mode">python-mode</a>, and the third one is <a rel="nofollow" target="_blank" href="https://www.vim.org/scripts/script.php?script_id=790">python.vim</a>.
Among others the python-syntax project site lists a high number of improvements such as highlighting for exceptions, doctests, errors, and constants. A nice feature is the switch between syntax highlighting for Python 2 and 3 based on an additional Vim command - <code>:Python2Syntax</code> and <code>:Python3Syntax</code>. This helps to identify possible changes that are required to run your script with both versions.
<img class="img-responsive" alt="Changing between Python 2 and 3" src="https://s3.amazonaws.com/stackabuse/media/vim-for-python-development-6.png">
<h2 id="combiningvimwiththerevisioncontrolsystemgit">Combining Vim with the Revision Control System Git</h2>
Revision control is quite essential for developers, and Git is probably the best system for that. Compiling Python code, the interpreter creates a number of temporary files like <code>__pycache__</code> and <code>*.pyc</code>. The changes of these files need not to be tracked in Git. To ignore them Git offers the feature of a so-called <code>.gitignore</code> file. Create this file in your Git-managed development branch with the following contents:
<pre><code class="hljs">*.pyc
__pycache__
</code></pre>
Also, add a <code>README</code> file for your project to document what it is about. No matter how small your project is, the <code>README</code> file helps you (and others) to remember what the code is meant to do. Writing this file in Markdown format is especially helpful if you synchronize your Python code with your repository on GitHub. The <code>README</code> file is rendered automatically to HTML that can be viewed easily in your web browser, then.
Vim can collaborate with Git directly using special plugins. Among others there is <a rel="nofollow" target="_blank" href="https://github.com/tpope/vim-fugitive">vim-fugitive</a>, <a rel="nofollow" target="_blank" href="https://github.com/junegunn/gv.vim">gv.vim</a> and <a rel="nofollow" target="_blank" href="https://github.com/jreybert/vimagit">vimagit</a>. All of them are available from GitHub, and mostly as a package for Debian GNU/Linux.
Having downloaded vim-fugitive via <code>apt-get</code> it needs to be activated in a similar way as done before with the other plugins:
<pre><code class="hljs">$ vim-addons install fugitive 
Info: installing removed addon &#x27;fugitive&#x27; to /home/frank/.vim
Info: Rebuilding tags since documentation has been modified ...
Processing /home/frank/.vim/doc/
Info: done
</code></pre>
This plugin works with files that are tracked with Git, only. A large number of additional Vim commands become available such as <code>:Gedit</code>, <code>:Gdiff</code>, <code>:Gstatus</code>, <code>:Ggrep</code> and <code>:Glog</code>. As stated on the project website these Vim commands correspond with the following Git commands and actions:
<ul>
<li><code>:Gedit</code>: Edit a file in the index and write to it to stage the changes</li>
<li><code>:Gread</code> (<code>git checkout -- filename</code>): Load the content of the file in the current buffer</li>
<li><code>:Gwrite</code> (<code>git add</code>): Add the file to the list of currently tracked files</li>
<li><code>:Gdiff</code> (<code>git diff</code>): Bring up the staged version of the file side by side with the working tree version and use Vim's diff handling capabilities to stage a subset of the file's changes</li>
<li><code>:Gmove</code> (<code>git mv</code>): Move a file to a new location</li>
<li><code>:Gstatus</code> (<code>git status</code>): Show the current status of your Git directory</li>
<li><code>:Gcommit</code> (<code>git commit</code>): Commit your changes</li>
<li><code>:Ggrep</code> (<code>git grep</code>): Search for the given pattern in the Git repository</li>
<li><code>:Glog</code> (<code>git log</code>): Loads all previous revisions of a file into the quickfix list so you can iterate over them and watch the file evolve!</li>
<li><code>:Gblame</code> (<code>git blame</code>): Shows who did the last changes to a file</li>
</ul>
<img class="img-responsive" alt="Finding out who changed which line of code using `:Gblame`" src="https://s3.amazonaws.com/stackabuse/media/vim-for-python-development-7.png">
<h2 id="workingwithskeletons">Working With Skeletons</h2>
Skeleton files (or templates) are a nice feature of Vim that helps improve your productivity by adding default text to a file when a new one is created. For example, in many Python files you'll have the a <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Shebang_(Unix)">shebang</a>, license, docstring, and author info at the beginning of the file. It would be a hassle to have to type or even copy this info to each file. Instead, you can use skeleton files to add this default text for you.
Let's say, for example, you want all new Python files to start with the following text:
<pre><code class="hljs">#!/user/bin/env python3
&quot;&quot;&quot;
[Add module documentation here]

Author: Frank
Date: [Add date here]
&quot;&quot;&quot;
</code></pre>
You would create a file with this content and call it something like <code>skeleton.py</code>, and then move it to the directory <code>~/.vim/skeleton.py</code>. To tell Vim which file should be used as the skeleton file for Python, add the following to your <code>.vimrc</code> file:
<pre><code class="hljs">au BufNewFile *.py 0r ~/.vim/skeleton.py
</code></pre>
This tells Vim to use the specified skeleton file for all new files matching the filename <code>*.py</code>.
<h2 id="notesonusingplugins">Notes on Using Plug-ins</h2>
Usually, Vim is quite fast. The more plugins you activate the longer it takes. The start of Vim is delayed, and takes noticeably longer than before. Also, it is common that Debian/Ubuntu packages work out of the box, and the installation scripts include all the steps to set up the plugin properly. I noticed that this is not the case, and sometimes additional steps are required.
<h2 id="moreresources">More Resources</h2>
There are a number of courses and blog posts that cover various Vim settings for day-to-day use as a Python developer, which I'd highly recommend looking into.
The following course aims for you to master Vim on any operating system, helping you gain a level of knowledge and comfortability with the editor that's difficult to achieve by reading articles alone:
<ul>
<li><a class="udemy-link" rel="nofollow" target="_blank" href="https://stackabu.se/vim-masterclass">Vim Masterclass</a></li>
</ul>
The rest are some great resources from around the web that we've found to be very helpful as well:
<ul>
<li><a rel="nofollow" target="_blank" href="https://linuxhint.com/vim-python-development/">Setup VIM for Python Development</a></li>
<li><a rel="nofollow" target="_blank" href="https://www.fullstackpython.com/vim.html">Full Stack Python</a></li>
<li><a rel="nofollow" target="_blank" href="http://liuchengxu.org/posts/use-vim-as-a-python-ide/">Use Vim as a Python IDE</a></li>
</ul>
These articles help to extend your knowledge. Enjoy :)
<h2 id="acknowledgements">Acknowledgements</h2>
The author would like to thank Zoleka Hatitongwe for her help and critical comments while preparing the article.

Frank Hofmann

Vim for Python Development

Dhananjay Singh

Spring Reactor Tutorial

<h2 id="introduction">Introduction</h2>
The way in which information is obtained and handled is one of the most important aspects of the ethos of any programming language, more so for the information supplied and obtained from the user.
Python, while comparatively slow in this regard when compared to other programming languages like C or Java, contains robust tools to obtain, analyze, and process data obtained directly from the end user.
<blockquote>
In this article, we'll take a brief look at how to obtain information from the user through the <code>input()</code> function in Python with the help of some code snippets to serve as examples.
</blockquote>
<h2 id="inputinpython">Input in Python</h2>
To receive information through the keyboard, Python uses the <code>input()</code> function. This function has an optional parameter, commonly known as prompt, which is a string that will be printed on the screen whenever the function is called.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Before Python 3 introduced the <code>input()</code> function, the way to go when reading the user input was the <code>raw_input()</code> function. Still, it's always advised to use Python 3 and its <code>input()</code> function whenever you can! 
In Python 3, the <code>raw_input()</code> function has been deprecated and replaced by the <code>input()</code> function and is used to obtain a user's string through the keyboard. And the <code>input()</code> function of Python 2 is discontinued in version 3. To obtain the same functionality that was provided by Python 2's <code>input()</code> function, the statement <code>eval(input())</code> must be used in Python 3.

 </div>
 </div>
 </div>
 When the <code>input()</code>function is called, the program flow stops until the user enters the input via the command line. To actually enter the data, the user needs to press the ENTER key after inputting their string. While hitting the ENTER key usually inserts a newline character (<code>&quot;\n&quot;</code>), it does not in this case. The entered string will simply be submitted to the application.
Now that we understand the basic theory behind the <code>input()</code> function, let's take a look at how it actually works in Python:
<pre><code class="hljs"># Python 3

txt = input(&quot;Type something to test this out: &quot;)

print(f&quot;Is this what you just said? {txt}&quot;)
</code></pre>
Running the previous code will prompt us with the &quot;Type something to test this out:&quot; message. After we've typed something, it will print out what we've just typed:
<pre><code class="hljs">Type something to test this out: Let the Code be with you!

Is this what you just said? Let the Code be with you!
</code></pre>
<h3 id="stringandnumericinput">String and Numeric Input</h3>
The <code>input()</code> function, by default, will convert all the information it receives into a string. The previous example we showed demonstrates this behavior.
Numbers, on the other hand, need to be explicitly handled as such since they come in as strings originally. The following example demonstrates how numeric type information is received:
<pre><code class="hljs"># An input is requested and stored in a variable
test_text = input (&quot;Enter a number: &quot;)

# Converts the string into an integer. If you need
# to convert the user input into the decimal format,
# the float() function is used instead of int()
test_number = int(test_text)

# Prints in the console the variable as requested
print (&quot;The number you entered is: &quot;, test_number)
</code></pre>
Running the previous code will give us:
<pre><code class="hljs">Enter a number: 13
The number you entered is: 13
</code></pre>
The more common approach is to perform both reading input and converting it into an integer in one line:
<pre><code class="hljs">test_number = int(input(&quot;Enter a number: &quot;))
</code></pre>
Keep in mind that if the user doesn't actually enter an integer then this code will throw an exception, even if the entered string is a floating point number.
<h3 id="howtohandleexceptionswhenreadinginput">How to Handle Exceptions When Reading Input</h3>
There are several ways to ensure that the user enters valid information. One of the ways is to handle all the possible errors that may occur while the user enters the data. In this section we'll demonstrates some good <a target="_blank" href="https://stackabuse.com/python-exception-handling/">error handling</a> methods for errors that may arise when reading input.
But first, let us take a look at an example of some (potentially) unsafe code:
<pre><code class="hljs">test2word = input(&quot;Tell me your age: &quot;)
test2num = int(test2word)
print(&quot;Wow! Your age is &quot;, test2num)
</code></pre>
After running this code, say you enter the string &quot;Three&quot; instead of the number 3:
<pre><code class="hljs">Tell me your age: Three
</code></pre>
Here, when the <code>int()</code> function is called with the &quot;Three&quot; string, a <code>ValueError</code> exception is thrown and the program will stop and/or crash.
Now let's see how we would make this code safer to handle user input:
<pre><code class="hljs">test3word = input(&quot;Tell me your lucky number: &quot;)

try:
 test3num = int(test3word)
 print(&quot;This is a valid number! Your lucky number is: &quot;, test3num)
except ValueError:
 print(&quot;This is not a valid number. It isn&#x27;t a number at all! This is a string, go and try again. Better luck next time!&quot;)
</code></pre>
This code block will evaluate the new input. If the input is an integer represented as a string then the <code>int()</code> function will convert it into a proper integer. If not, an exception will be raised, but instead of crashing the application it will be caught and the second <code>print</code> statement is run. Here is an example of this code running when an exception is raised:
<pre><code class="hljs">Tell me your lucky number: Seven
This is not a valid number. It isn't a number at all! This is a string, go and try again. Better luck next time!
</code></pre>
And this is how input-related errors can be handled in Python.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: You can combine this code with another construct, like <a target="_blank" href="https://stackabuse.com/loops-in-python/">a while loop</a> to ensure that the code is repeatedly run until you receive the valid integer input that your program requires.

 </div>
 </div>
 </div>
 <h2 id="acompleteexample">A Complete Example</h2>
<pre><code class="hljs"># Make a function that will contain the
# desired program.
def example():

 # Call for an infinite loop that keeps executing
 # until an exception occurs
 while True:
 test4word = input(&quot;What&#x27;s your name? &quot;)

 try:
 test4num = int(input(&quot;From 1 to 7, how many hours do you use your smartphone?&quot; ))

 # If something else that is not the string
 # version of a number is introduced, the
 # ValueError exception will be called.
 except ValueError:
 # The cycle will go on until validation
 print(&quot;Error! This is not a number. Try again.&quot;)

 # When successfully converted to an integer,
 # the loop will end.
 else:
 print(&quot;Impressive, &quot;, test4word, &quot;! You spent&quot;, test4num*60, &quot;minutes or&quot;, test4num*60*60, &quot;seconds using your smartphone!&quot;)
 break

# The function is called
example()
</code></pre>
The output will be:
<pre><code class="hljs">What's your name? Francis

From 1 to 7, how many hours do you use your smartphone?

Impressive, Francis! You spent 180 minutes or 10800 seconds using your smartphone!
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we saw how the built-in Python <code>input()</code> function can be used to get user input in a variety of formats. We also saw how we can handle the exceptions and errors that can possibly occur while obtaining user input.

Dimitrije Stamenic

In this tutorial, we'll take a brief look at how to obtain information from the user through the input() function in Python.

Getting User Input in Python

Creating a Neural Network from Scratch in Python: Multi-class Classification

Adam McQuistan

Java's Object Methods: hashCode()