<h2 id="introduction">Introduction</h2>
The <code>or</code> operator is one of the three existing logical operators in Python (<code>and</code>, <code>or</code>, <code>not</code>), which perform a logical evaluation of the passed operands.
In simple terms, when two operands are passed, it will decide whether the final value of the created logical expression is <code>True</code> or <code>False</code>. The mechanism used to evaluate the value of the final expression is based on the set of rules known as Boolean algebra.
<blockquote>
In this guide, we'll cover the <code>or</code> operator in Python as well as its most common use cases.
</blockquote>
<h2 id="oroperatorbasics">or Operator Basics</h2>
Python's <code>or</code> operator just performs logical disjunction on the two provided operands. Assuming that the operands are simply two Boolean values, the rule on how to use the <code>or</code> operator is pretty straight-forward:
<blockquote>
If either one of two operands has the value <code>True</code>, the whole expression has the value <code>True</code>. In all other cases, the whole expression has the value <code>False</code>.
</blockquote>
Now let's take a look at the truth table of the <code>or</code> operator:
<table class="table table-striped">
 <tr>
 <td>Operand 1</td>
 <td>Operand 2</td>
 <td>OR Expression Value</td>
 </tr>
 <tr>
 <td>True</td>
 <td>True</td>
 <td>True</td>
 </tr>
 <tr>
 <td>True</td>
 <td>False</td>
 <td>True</td>
 </tr>
 <tr>
 <td>False</td>
 <td>True</td>
 <td>True</td>
 </tr>
 <tr>
 <td>False</td>
 <td>False</td>
 <td>False</td>
 </tr>
</table>
This table describes the law of logical disjunction. By looking at this table, we can see that the <code>or</code> operator produces <code>False</code> as the result only if both of the operands are <code>False</code> as well.
All of this leads us to the concept of lazy evaluation. A mechanism used to optimize calculations of mathematical operations. In this particular case, it is used to speed up the process of evaluating Boolean expressions with the <code>or</code> operator.
We already know that an <code>or</code> expression results in a <code>True</code> value if either of its two operands is <code>True</code>. Therefore, in a Boolean expression consisting of multiple operands, it is completely unnecessary to evaluate each one of them individually.
It's enough just to read the values of operands one after the other. When we come across a <code>True</code> for the first time, we can safely just ignore all of the other operands and just evaluate the whole expression as <code>True</code>.
On the other hand, if there is no operand with the value <code>True</code>, we must evaluate the whole expression with the value <code>False</code>. That is the basic principle of lazy evaluation - don't evaluate if you don't have to.
<h2 id="usingoronbooleanvariables">Using or on Boolean Variables</h2>
The <code>or</code> operator in Python is used to evaluate two of its operands. In this section, we'll focus on the case where both of the operands have Boolean values. In some cases, the <code>or</code> operator can be used with non-Boolean values, which we'll discuss in the following sections.
Let's take a look at how to use the <code>or</code> operator with two Boolean values:
<pre><code class="hljs"># Two Boolean values
result1 = True or False # Expected to be `True`
result2 = False or False # Expected to be `False`

print(&#x27;R1:&#x27;, result1)
print(&#x27;R2:&#x27;, result2)
</code></pre>
In this example, we can see how the <code>or</code> operator evaluates expressions consisting only of simple Boolean values. As described in the previous sections, this piece of code will have the following output:
<pre><code class="hljs">R1: True
R2: False
</code></pre>
In the previous example, we've named Boolean expressions <code>result1</code> and <code>result2</code>. That way, we've created two Boolean variables with values <code>True</code> and <code>False</code>, respectively.
Those two variables can be used as the operands of another Boolean expression and, therefore, could be considered as subexpressions of the more complex Boolean expression. That's the general principle used to build more complex Boolean expressions layer by layer:
<pre><code class="hljs">result3 = result1 or result2 # `True` or `False` &lt;=&gt; `True`
result4 = result3 or True # `True` or `True` &lt;=&gt; `True`

print(&#x27;R3:&#x27;, result3)
print(&#x27;R4:&#x27;, result4)
</code></pre>
As expected, this will output:
<pre><code class="hljs">R3: True
R4: True
</code></pre>
<code>result4</code> is a complex Boolean expression consisting of multiple subexpressions and Boolean values. Let's take a look at the process of unfolding it:
<pre><code class="hljs">1. result4 = result3 or True
2. result4 = (result1 or result2) or True
3. result4 = ((True or False) or (False or False)) or True
</code></pre>
Based on the associative law for the <code>or</code> operator, we know that the order in which we apply the operator doesn't have an impact on the value of the Boolean expression, so there is no need for brackets. Therefore, we can transform <code>result4</code> one step further by deleting all of the brackets:
<pre><code class="hljs"> result4 = True or False or False or False or True
</code></pre>
<h2 id="usingoronnonbooleanvariables">Using or on Non-Boolean Variables</h2>
The <code>or</code> operator in Python can also be used with variables other than Boolean. You can even mix and match Boolean variables with non-Boolean variables. In this section, we'll go over some examples that illustrate the usage of the <code>or</code> operator with variables of different data types.
Generally speaking, any object or a variable in Python is considered to be <code>True</code> unless its class has a predefined <code>__bool__()</code> method that returns <code>False</code> or a <code>__len__()</code> method that returns <code>0</code>.
In simple terms that means that only objects considered to be <code>False</code> are those which are predefined to be <code>False</code> or those which are empty - empty lists, tuples, strings, dictionaries... <a target="_blank" rel="nofollow noopener noreferrer" href="https://docs.python.org/3/library/stdtypes.html">The Official Python documentation</a> gives us the list of some of the most common built-in objects considered to be <code>False</code>:
<ul>
<li>Constants defined to be false: <code>None</code> and <code>False</code>.</li>
<li>Zero of any numeric type: <code>0</code>, <code>0.0</code>, <code>0j</code>, <code>Decimal(0)</code>, <code>Fraction(0, 1)</code></li>
<li>Empty sequences and collections: <code>''</code>, <code>()</code>, <code>[]</code>, <code>{}</code>, <code>set()</code>, <code>range(0)</code></li>
</ul>

 <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: These are also known as Falsy Values - the ones you'd intuitively be able to reduce to a <code>False</code> boolean value. The opposite values are Truthy Values.

 </div>
 </div>
 </div>
 <blockquote>
Another very important fact is that the <code>or</code> operator in this case returns the actual object, not the <code>True/False</code> value of the object.
</blockquote>
Let's take a look at the example that illustrates mentioned behavior:
<pre><code class="hljs">exp = {} or &#x27;This is a string&#x27;
</code></pre>
As stated before, the first operand - <code>{}</code> (empty dictionary) is considered to be <code>False</code> and the second operand - <code>'This is a string'</code> (not an empty string) is considered to be <code>True</code>. This means that the previous expression is implicitly transformed to:
<pre><code class="hljs"># exp = False or True
</code></pre>
Here, <code>exp</code> is evaluated to <code>True</code>. But, when we try to print the original <code>exp</code> value, instead of <code>True</code>, the output will be:
<pre><code class="hljs">&#x27;This is a string&#x27;
</code></pre>
This example illustrates the case when the <code>or</code> operator returns the object itself instead of its <code>True/False</code> value. To sum this behavior up, we can illustrate it with the altered (truth) table of the <code>or</code> operator:
<table class='table table-striped'>
 <tr>
 <td>object1 (value)</td>
 <td>object2 (value)</td>
 <td>object1 `or` object2 (return value)</td>
 </tr>
 <tr>
 <td>True</td>
 <td>True</td>
 <td>object1</td>
 </tr>
 <tr>
 <td>True</td>
 <td>False</td>
 <td>object1</td>
 </tr>
 <tr>
 <td>False</td>
 <td>True</td>
 <td>object2</td>
 </tr>
 <tr>
 <td>False</td>
 <td>False</td>
 <td>object2</td>
 </tr>
</table>
This also applies when we combine usual Boolean values and objects in Boolean expressions.
If the expression contains at least one value that is considered to be <code>True</code>, the value of the expression is <code>True</code>, but the return value can vary based on the first <code>True</code> element in it.
If the first <code>True</code> operand to be found in the expression is a simple Boolean value, the return value will be <code>True</code>, but if the first <code>True</code> element is some sort of an object, the return value will be that object itself. For example, the following expression will return <code>True</code>:
<pre><code class="hljs">0 or True 
</code></pre>
And the following expression will return <code>[1, 2, 3]</code>, which is the first <code>True</code> operand found:
<pre><code class="hljs">False or [1, 2, 3]
</code></pre>
On the other hand, if a Boolean expression is <code>False</code>, meaning that no <code>True</code> operand was found, its return value will be its last operand, either object or <code>False</code>:
<pre><code class="hljs">{} or 0.0 or [] or False or ()
# Output &gt;&gt; ()
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this guide, we've explained the usage of the <code>or</code> operator in Python. We've introduced the syntax in Python and described how the <code>or</code> operator evaluates Boolean expressions and how it determine the proper return value based on the operands.
Besides its primary usage for evaluating Boolean expressions, the <code>or</code> operator can also be pretty useful in some other use cases.
Its features make it a good choice when you need to set default values for some variables or a default return value of a function and much more, but those special use cases are far beyond the scope of this article, so we'll let you explore all the use cases that the <code>or</code> operator can be utilized in.

Vladimir Batoćanin

Dimitrije Stamenic

In this guide, we'll take a look at how to use the Python or operator, how Boolean algebra works, what truthy and falsy values are in Python, as well as how to use the or operator both with boolean and non-boolean values.

Guide to the Python or Operator

David Landup

Marcus Sanatan

Reham Muzzamil

In this guide, learn what the difference is between Java 8's map() and flatMap() methods are, in the context of Optionals and the Stream API, with practical code examples and use cases.

Java 8 - Difference Between map() and flatMap()

<h2 id="introduction">Introduction</h2>
A stream represents a sequence of elements and supports different kinds of operations that lead to the desired result. The source of a stream is usually a Collection or an Array, from which data is streamed from.
Streams differ from collections in several ways; most notably in that the streams are not a data structure that stores elements. They're functional in nature, and it's worth noting that operations on a stream produce a result and typically return another stream, but do not modify its source.
To &quot;solidify&quot; the changes, you collect the elements of a stream back into a <code>Collection</code>.
<blockquote>
In this guide, we'll take a look at how to collect and reverse a list in Java.
</blockquote>
<h2 id="collectandreversealistinjava">Collect and Reverse a List in Java</h2>
The first approach would be to <code>collect()</code> the stream into a list - and then use the <code>Collections.reverse()</code> method on the list, which reverses it in-place.

 <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: If you also want to sort the collection while reversing it, you can use the <code>sorted(Comparator.reverseOrder())</code> method in the chain. However, this will impose a completely new relative order of elements.

 </div>
 </div>
 </div>
 Let's define a stream with some elements, collect it into a list, reverse the list and print it:
<pre><code class="hljs">Stream&lt;?&gt; s = Stream.of(1, 2, 3, 4, 5);

List&lt;?&gt; list = s.collect(Collectors.toList());
Collections.reverse(list);
System.out.println(list);
</code></pre>
This results in:
<pre><code class="hljs">[5, 4, 3, 2, 1]
</code></pre>
This works well, but there's a simpler way to do this - all in one method. The <code>collectingAndThen()</code> method allows us to chuck in an additional finishing transformation <code>Function</code> besides the <code>collect()</code> method. This way, we can collect the stream and perform the <code>Collections.reverse()</code> call in the same <code>collect()</code> call!
<h2 id="collectandreversealistwithcollectingandthen">Collect and Reverse a List with collectingAndThen()</h2>
<blockquote>
If you'd like to read more about <code>collectingAndThen()</code> - read our detailed, definitive <a target="_blank" href="https://stackabuse.com/guide-to-java-8-collectors-collectingandthen/">Guide to Java 8 Collectors: collectingAndThen()</a>!
</blockquote>
Let's take a look at how we can use <code>collectingAndThen()</code> to bundle the transformations into a single call:
<pre><code class="hljs">Stream&lt;?&gt; s = Stream.of(1, 2, 3, 4, 5);

List&lt;?&gt; list = s.collect(
 Collectors.collectingAndThen(
 Collectors.toList(),
 l -&gt; {Collections.reverse(l); return l; }
 )
);

System.out.println(list);
</code></pre>
Here, we've supplied an adapter <code>Collector</code> to the <code>collect()</code> method. The adapted collector runs <code>Collectors.toList()</code>, and a Lambda function to reverse and return the reversed list. Finally - the returned value is assigned to the <code>list</code> reference variable!
<blockquote>
If you'd like to read more about Functional Interfaces and Lambda Expressions in Java - read our <a target="_blank" href="https://stackabuse.com/guide-to-functional-interfaces-and-lambda-expressions-in-java/">Guide to Functional Interfaces and Lambda Expressions in Java</a>!
</blockquote>
This results in:
<pre><code class="hljs">[5, 4, 3, 2, 1]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this short guide, we've taken a look at how you can collect and reverse a stream/list in Java 8, using <code>collect()</code> and <code>Collections.reverse()</code> - individually, and together through the <code>collectingAndThen()</code> method.

Hiram Kamau

In this tutorial, learn how to collect and reverse a stream into a list in Java 8 with Collectors.toList() and Collections.reverse(), as well as Collectors.collectingAndThen()!

Java 8 Streams - Collect and Reverse Stream into List

Olivera Popović

In this parent-guide - learn what you need to know about Graphs in Computer Science and focus on graph-related algorithm's theory and implementation - DFS, BFS, Dijkstra, A*, Minimum Spanning Trees, etc...

Graph Theory and Graph-Related Algorithm's Theory and Implementation

<h2 id="introduction">Introduction</h2>
Flask is one of the most popular Python web development frameworks. It's a lightweight web framework, yet it offers a variety of built-in methods that can be used for hassle-free deployment of efficient web applications.
<blockquote>
In this guide, we will get the IP address of the user who visits the web application created using Flask.
</blockquote>
We'll create a simple REST API that handles the incoming requests to the <code>/</code> endpoint, returning the IP address of the user as the response.
<h2 id="creatingabasicwebappusingflask">Creating a Basic Web App Using Flask</h2>
Create a new Flask project for this tutorial. We'll create a basic app that returns &quot;Hello World&quot; with requests to the <code>/</code> endpoint:
<pre><code class="hljs">from flask import Flask

# Creating the instance of the class Flask
app = Flask(__name__)

# Using the decorator to create the URL for the web application
@app.route(&#x27;/&#x27;)
# The function will return the information displayed on the webpage
def hello_world():
 return &#x27;&lt;h1&gt; Hello World&lt;/h1&gt;&#x27;

# Run the application
if __name__ == &#x27;__main__&#x27;:
 app.run(debug=True)
</code></pre>
Now that we have our app set up, let's collect the IP addresses associated with a user's request.
<h2 id="howtofindtheipaddressofauserinflask">How to Find the IP Address Of a User in Flask?</h2>
Whenever a client requests a page - they send an HTTP GET request, with a certain payload. Amongst other information - their distinctive IP address is included. In Flask - every route has access to the <code>request</code> variable, which represents the incoming request from the user.
From this <code>request</code>, we can extract various elements - and the IP address is denoted as the <code>remote_addr</code> property:
<pre><code class="hljs">@app.route(&#x27;/&#x27;)
def hello_world():
 ip_addr = request.remote_addr
 return &#x27;&lt;h1&gt; Your IP address is:&#x27; + ip_addr
</code></pre>
We can also get the remote address through the request context's environment. The <code>environ</code> dictionary of the <code>request</code> object holds various keys and their respective values, pertaining to the request. The <code>REMOTE_ADDR</code> is one of the server variables (keys) that is mapped to the IP address of the client or the server:
<pre><code class="hljs">@app.route(&#x27;/client&#x27;)
def client():
 ip_addr = request.environ[&#x27;REMOTE_ADDR&#x27;]
 return &#x27;&lt;h1&gt; Your IP address is:&#x27; + ip_addr
</code></pre>
But the above two options won't work if your user is making a request behind a proxy. In that case we have to check the headers of the request. In particular, we're looking for the <code>HTTP_X_FORWARDED_FOR</code> header:
<pre><code class="hljs">@app.route(&#x27;/proxy-client&#x27;)
def proxy_client():
 ip_addr = request.environ[&#x27;HTTP_X_FORWARDED_FOR&#x27;]
 return &#x27;&lt;h1&gt; Your IP address is:&#x27; + ip_addr
</code></pre>
Now, even this approach would not work if the header is not set. So a common strategy is to use the <code>get()</code> method so that if the header is not set, we can default to the remote address:
<pre><code class="hljs">@app.route(&#x27;/proxy-client&#x27;)
def proxy_client():
 ip_addr = request.environ.get(&#x27;HTTP_X_FORWARDED_FOR&#x27;, request.remote_addr)
 return &#x27;&lt;h1&gt; Your IP address is:&#x27; + ip_addr
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Trying to get a value from a non-existent key returns <code>None</code>. The <code>get()</code> method of the <code>dict</code> class allows you to set a default value to be used if <code>get()</code> fails to find a key. If <code>HTTP_X_FORWARDED_FOR</code> is <code>None</code>, the <code>request.remote_addr</code> value is used instead.

 </div>
 </div>
 </div>
 With these in mind, we can choose from any of the following three approaches to get the IP address of a user, via their incoming request:
<pre><code class="hljs">from flask import Flask, request

app = Flask(__name__)

@app.route(&#x27;/&#x27;)
def hello_world():
 ip_addr = request.remote_addr
 return &#x27;&lt;h1&gt; Your IP address is:&#x27; + ip_addr


@app.route(&#x27;/client&#x27;)
def client():
 ip_addr = request.environ[&#x27;REMOTE_ADDR&#x27;]
 return &#x27;&lt;h1&gt; Your IP address is:&#x27; + ip_addr


@app.route(&#x27;/client&#x27;)
def proxy_client():
 ip_addr = request.environ.get(&#x27;HTTP_X_FORWARDED_FOR&#x27;, request.remote_addr)
 return &#x27;&lt;h1&gt; Your IP address is:&#x27; + ip_addr


if __name__ == &#x27;__main__&#x27;:
 app.run(debug=True)
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we learned three different methods to get the IP address of a user. We access the remote address directly with <code>request.remote_addr</code>, through the <code>REMOTE_ADDR</code> key from <code>request.environ</code>, and in the cases where the user is using a proxy we should check the <code>HTTP_X_FORWARDED_FOR</code> key of <code>request.environ</code>.

Mohammad Waseem

In this tutorial, we will take a look at how to get the IP address of the user who visits a web application created using Flask.

How To Get User's IP Address Using Flask?

Jovana Ninkovic

In this definitive, detailed guide - learn all you need to know about Java Collectors' collectingAndThen(), whether it's efficient, and try out a hands-on data analysis project.

Guide to Java 8 Collectors: collectingAndThen()

Query Parameters are part of the Query String - a section of the URL that contains key-value pairs of parameters. Typically, parameters are sent alongside GET requests to further specify filters on the operation:
<pre><code class="hljs">www.example.com/search?name=John&amp;location=Miami
</code></pre>
The parameters are defined after the <code>?</code> character and each key-value pair is separated with a <code>&amp;</code>. Spaces are represented as <code>%20</code> and can also be represented as <code>+</code>. These map to a key-value set of:
<pre><code class="hljs">name=John
location=Miami
</code></pre>
It's easy to manipulate the URL with JavaScript - so more often than not, query parameters are added as filters to searches. Additionally, by adjusting the content on the screen based on reproducible parameters, instead of the body of a request, results are shareable between users just by sending a link with the parameters!
For instance, on AirBnB - if you're fully flexible on the location, dates and wish for an auto-suggest, a click of a button leads you to:
<pre><code class="hljs">https://www.airbnb.com/s/homes?refinement_paths%5B%5D=%2Fhomes&amp;date_picker_type=flexible_dates&amp;search_mode=flex_destinations_search&amp;search_type=AUTOSUGGEST
</code></pre>
There are a few parameters here, such as <code>refinement_paths</code>, <code>date_picker_type</code>, <code>search_mode</code>, and <code>search_type</code>, each with a value.
<blockquote>
In this short guide, we'll take a look at how to get a GET Request's Query Parameters in Flask.
</blockquote>
<h2 id="getqueryparametersinflask">Get Query Parameters in Flask</h2>
<pre><code class="hljs">from flask import Flask, request
# ...
@app.route(&#x27;/search&#x27;, methods=[&#x27;GET&#x27;])
def search():
 args = request.args
 return args
</code></pre>
The <code>request.args</code> field is an <code>ImmutableMultiDict</code>:
<pre><code class="hljs">print(type(args))
# &lt;class &#x27;werkzeug.datastructures.ImmutableMultiDict&#x27;&gt;
</code></pre>
It can easily be converted into a regular dictionary via:
<pre><code class="hljs">print(type(args.to_dict()))
# &lt;class &#x27;dict&#x27;&gt;
</code></pre>
Additionally, you can search for a specific key in the dictionary via the <code>get()</code> method, returning an error if the key doesn't match up to the preconceived argument list:
<pre><code class="hljs">print(args.get(&quot;name&quot;))
# John
</code></pre>
You can additionally cast the value to a different type, such as <code>int</code> or <code>str</code> while getting it. You can also set a default value if the value isn't present already. For instance, a <code>name</code> parameter will probably be a string, but the <code>price</code> parameter might be an integer:
<pre><code class="hljs">args.get(&quot;name&quot;, default=&quot;&quot;, type=str)
args.get(&quot;price&quot;, default=0, type=int)
</code></pre>
If you search for a non-existent key - a <code>None</code> is returned. This way, you can check whether a query parameter is missing, and act accordingly - assigning a default value or just not using it.
Let's send a GET request to the endpoint with a <code>name</code> and <code>location</code>:
<pre><code class="hljs">$ curl &quot;localhost:5000/search?name=John&amp;location=Miami&quot;
</code></pre>
This results in:
<pre><code class="hljs">{&quot;location&quot;:&quot;Miami&quot;,&quot;name&quot;:&quot;John&quot;}
</code></pre>
<h2 id="checkifqueryparametersarenotnone">Check if Query Parameters are Not None</h2>
When operating on parameters, you'll typically want to check if they're <code>None</code> and act accordingly. This can thankfully easily be done by getting an expected key and checking if it's present in the dictionary!
Let's create a mock database - just a dictionary of users and their locations. Then, based on the parameters passed in the URL, we'll filter this dictionary and return the matching users that fit the criteria defined by the parameters:
<pre><code class="hljs">from flask import Flask, request
# ...
db_users = {
 &quot;John&quot; : &quot;Miami&quot;,
 &quot;David&quot; : &quot;Miami&quot;,
 &quot;Jane&quot; : &quot;London&quot;,
 &quot;Gabriella&quot; : &quot;Paris&quot;,
 &quot;Tanaka&quot; : &quot;Tokyo&quot;
}

@app.route(&#x27;/search&#x27;, methods=[&#x27;GET&#x27;])
def search():
 args = request.args
 name = args.get(&#x27;name&#x27;)
 location = args.get(&#x27;location&#x27;)

 # result = db_users
 if None not in (name, location):
 result = {key: value for key, value in db_users.items() if key == name and value == location}
 elif name is not None:
 result = {key: value for key, value in db_users.items() if key == name}
 elif location is not None:
 result = {key: value for key, value in db_users.items() if value == location}

 return result
</code></pre>
Here - we extract the <code>name</code> and <code>location</code> from the parameter list. If none are present - you may wish to return all of the users, or none at all. If you'd wish to return all of them - uncomment the <code>result = db_users</code> line.
If both the <code>name</code> and <code>location</code> are present, we filter the <code>db_users</code> by both parameters. If only one is present - we filter it only using the present parameter.
Now, if we send a GET Request with both or a single parameter, we'll be greeted with:
<pre><code class="hljs">$ curl &quot;localhost:5000/search?name=John&amp;location=Miami&quot;
{&quot;John&quot;:&quot;Miami&quot;}

$ curl &quot;localhost:5000/search?name=John&quot;
{&quot;John&quot;:&quot;Miami&quot;}

$ curl &quot;localhost:5000/search?location=Miami&quot;
{&quot;David&quot;:&quot;Miami&quot;,&quot;John&quot;:&quot;Miami&quot;}
</code></pre>
Two people are located in Miami, so just using the single search parameter nets us two users. There's only one John in the dictionary, so only John is returned for the first two queries.
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to get the query parameters of an HTTP GET Request in Flask.
We've also taken a look at how to check whether the parameters are <code>None</code> and how to handle the lack thereof with a mock database.

In this guide, we'll take a look at how to get the query parameters/arguments, handle missing values, set default values and cast parameters to different data types. in Flask - a lightweight Pyton framework for web development.

GET Request Query Parameters with Flask

<h2 id="introduction">Introduction</h2>
Flask is a great micro-framework for Web Development in Python, and allows you to be extremely minimal. A working REST API can be served up in seconds through a few lines of code:
<pre><code class="hljs">from flask import Flask, request
app = Flask(__name__)

@app.route(&#x27;/&#x27;)
def hello():
 return &#x27;Hello!&#x27;

if __name__ == &quot;__main__&quot;:
 app.run()
</code></pre>
The backbone of the modern web is the HTTP protocol - which sends requests and delivers responses back. To differentiate the intentions behind these requests, several &quot;verbs&quot; have been associated with tasks you're performing. <code>GET</code> verbs are used to annotate requests in which you wish to retrieve resources, <code>POST</code> verbs are used to request resources to be created, given the payload (body), <code>DELETE</code> verbs are used to request resource deletion, etc.
If you wish to create a resource on a server - you'll be sending a POST Request with a body that contains the data you're posting to the server.
<blockquote>
In this guide, we'll take a look at how to get an HTTP POST Body in Flask.
</blockquote>
In general, you'll most likely be posting JSON data to a REST API that consumes that data, or you'll be posting Form data - by having a user fill out a web form, and then sending that data to another API for processing.
When sending form data - it's typically encoded as <code>multipart/form-data</code>, while when sending JSON data - it's typically encoded as <code>application/json</code>. This information is embedded in the POST Request Header which you can, also check. For good measure - we'll be checking the request's headers before parsing the data.
When dealing with requests - the <code>request</code> module of <code>flask</code> allows you to represent incoming HTTP requests. A POST request's body can be extracted directly from the request itself and depending on the encoding - you'll access the appropriate field:
<ul>
<li><code>request.json</code> or <code>request.get_json()</code></li>
<li><code>request.form</code></li>
<li><code>request.data</code></li>
</ul>
<code>request.json</code> represents JSON sent as a request with the <code>application/json</code> content-type. Alternatively, you can use the <code>request.get_json()</code> method. Both accessing the field itself and the method returns a <code>dict</code> - with <code>key-value</code> pairs present in the incoming JSON.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: The <code>json</code> field and <code>get_json()</code> methods will only work if the Content-Type of the POST request is set to <code>application/json</code>. If it's a JSON-formatted string - this approach will fail and result in a <code>None</code> value. If you can't enforce the client to send properly encoded data - you can convert the incoming string into JSON. Covered later in the guide.

 </div>
 </div>
 </div>
 <code>request.form</code> represents the <code>multipart/form-data</code> data that is acquired through web forms.
<code>request.data</code> is a string representation of the incoming data. In general - you'll use this representation to convert into JSON if you can't force the client to send the content-type you're expecting.
<h3 id="getpostjson">Get POST JSON</h3>
Let's start out with JSON - since this is the most commonly used format to transfer data between APIs. We'll create a simple route handler that receives a <code>POST</code> request, on the <code>/post_json</code> endpoint. Remember, the <code>json</code> field will only ever contain a value if the headers of the request properly annotate the body as an <code>application/json</code> payload.
Here, we'll also get the 'Content-Type' from the <code>headers</code> and check if the body indeed is <code>application/json</code> formatted. If not - we won't even try extracting JSON from the request (it will silently fail if we do) and an error message is returned:
<pre><code class="hljs">from flask import Flask, request
# ...
@app.route(&#x27;/post_json&#x27;, methods=[&#x27;POST&#x27;])
def process_json():
 content_type = request.headers.get(&#x27;Content-Type&#x27;)
 if (content_type == &#x27;application/json&#x27;):
 json = request.json
 return json
 else:
 return &#x27;Content-Type not supported!&#x27;
</code></pre>
If you send a POST request to your endpoint now - you'll be greeted with the JSON returned back:
<pre><code class="hljs">$ curl -X POST -H &quot;Content-type: application/json&quot; -d &quot;{\&quot;firstName\&quot; : \&quot;John\&quot;, \&quot;lastName\&quot; : \&quot;Smith\&quot;}&quot; &quot;localhost:5000/post_json&quot;
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Depending on the operating system and shell you're using - you might use <code>'</code> instead of <code>&quot;</code> or even skip the escape characters such as <code>\</code> altogether.

 </div>
 </div>
 </div>
 This results in:
<pre><code class="hljs">{&quot;firstName&quot;:&quot;John&quot;,&quot;lastName&quot;:&quot;Smith&quot;}
</code></pre>
Awesome! Let's try setting the <code>-H</code> argument to another type - to check if the validation step works well:
<pre><code class="hljs">$ curl -X POST -H &quot;Content-type: multipart/form-data&quot; -d &quot;{\&quot;firstName\&quot; : \&quot;John\&quot;, \&quot;lastName\&quot; : \&quot;Smith\&quot;}&quot; &quot;localhost:5000/post_json&quot;
</code></pre>
This results in:
<pre><code class="hljs">Content-Type not supported!
</code></pre>
Alternatively, <code>get_json()</code> works in much the same way:
<pre><code class="hljs">from flask import Flask, request
# ...
@app.route(&#x27;/post_json&#x27;, methods=[&#x27;POST&#x27;])
def process_json():
 content_type = request.headers.get(&#x27;Content-Type&#x27;)
 if (content_type == &#x27;application/json&#x27;):
 json = request.get_json()
 return json
 else:
 return &#x27;Content-Type not supported!&#x27;
</code></pre>
<h3 id="getpostjsonfromstring">Get POST JSON from String</h3>
We were the ones sending the request so far - so we had the liberty of changing the content-type as we saw fit. This might not always be the case - and sometimes, you can run into a JSON-formatted request that doesn't have the correct content-type assigned to it.
In that case - <code>json</code> and <code>get_json()</code> don't parse the incoming body as JSON at all - and will end up being <code>None</code>, out of which you can't extract anything. In such cases - you can use the <code>json</code> module to load the string you've received into a dictionary (<code>key-value</code> pairs)!
Let's import the module and convert the incoming <code>request.data</code>:
<pre><code class="hljs">from flask import Flask, request, json
# ...
@app.route(&#x27;/post_json&#x27;, methods=[&#x27;POST&#x27;])
def process_json():
 data = json.loads(request.data)
 return data
</code></pre>
Now - whether you send a <code>text/plain</code>-encoded body, or an <code>application/json</code>-encoded body - the <code>json</code> module can handle the input. If we try sending either of these requests - they'd both result in the same response:
<pre><code class="hljs">$ curl -X POST -H &quot;Content-type: application/json&quot; -d &quot;{\&quot;firstName\&quot; : \&quot;John\&quot;, \&quot;lastName\&quot; : \&quot;Smith\&quot;}&quot; &quot;localhost:5000/post_json&quot;
$ curl -X POST -H &quot;Content-type: text/plain&quot; -d &quot;{\&quot;firstName\&quot; : \&quot;John\&quot;, \&quot;lastName\&quot; : \&quot;Smith\&quot;}&quot; &quot;localhost:5000/post_json&quot;
</code></pre>
They result in:
<pre><code class="hljs">{&quot;firstName&quot;:&quot;John&quot;,&quot;lastName&quot;:&quot;Smith&quot;}
</code></pre>
<h3 id="getpostform">Get POST Form</h3>
When filling out forms - you have a series of inputs, and their corresponding labels. Under the hood - these are all just <code>key-value</code> pairs:
<pre><code class="hljs">username=user_input
password=user_input_2
...
</code></pre>
This is typically derived from the front-end - usually an HTML page with a <code>&lt;form&gt;</code> tag with several <code>&lt;input&gt;</code> fields within it. You can also send form data via <code>curl</code> as:
<pre><code class="hljs">$ curl -X POST -H &quot;Content-type: multipart/form-data&quot; -F &quot;username=john&quot; -F &quot;password=doe&quot; &quot;localhost:5000/post_form&quot;
</code></pre>
Or, you can collapse all of the fields into a single argument:
<pre><code class="hljs">$ curl -X POST -H &quot;Content-type: multipart/form-data&quot; -F &quot;username=john&amp;password=doe&quot; &quot;localhost:5000/post_form&quot;
</code></pre>
In general - you'll be working with actual forms though, and a form we would be working with looks like:
<pre><code class="hljs">&lt;form action=&quot;/post_form&quot; enctype=&quot;multipart/form-data&quot; method=&quot;POST&quot;&gt; 
 &lt;input type=&quot;text&quot; name=&quot;username&quot;&gt;
 &lt;input type=&quot;password&quot; name=&quot;password&quot;&gt;
&lt;/form&gt;
</code></pre>
The <code>name</code> of each <code>&lt;input&gt;</code> is mapped as the <code>key</code> to a <code>value</code> input by the user. The <code>form</code> extracted from the <code>request</code> object is yet another <code>dict</code> - and you can access the fields individually easily:
<pre><code class="hljs">from flask import Flask, request
# ...
@app.route(&#x27;/post_form&#x27;, methods=[&#x27;POST&#x27;])
def process_form():
 data = request.form
 print(data[&#x27;username&#x27;])
 print(data[&#x27;password&#x27;]) 
 return data
</code></pre>
When we send a request via the console - the dictionary containing the key-value pairs is returned (which is then formatted again, as JSON):
<pre><code class="hljs">{&quot;password&quot;:&quot;doe&quot;,&quot;username&quot;:&quot;john&quot;}
</code></pre>
And on the server-end - the inputs for these two fields have been printed, right beneath the log for the incoming request
<pre><code class="hljs">127.0.0.1 - - [09/Dec/2021 00:24:32] &quot;POST /post_form HTTP/1.1&quot; 200 -
john
doe
</code></pre>
Naturally, instead of just printing the values to the console - you would validate the data, create a user, and persist them in the database. Alternatively, you can populate the fields of any class this way, before using that class for its purpose.
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to handle incoming HTTP POST requests in Flask. We've covered incoming JSON data, as well as how to handle string-represented JSON which isn't picked up automatically.
Finally, we've covered form data.

In this guide, learn how to get, parse and handle incoming POSTed JSON and Form data in Flask with Python!

How to Get and Parse HTTP POST Body in Flask - JSON and Form Data

<h2 id="introduction">Introduction</h2>
A stream represents a sequence of elements and supports different kinds of operations that lead to the desired result. The source of a stream is usually a Collection or an Array, from which data is streamed from.
Streams differ from collections in several ways; most notably in that the streams are not a data structure that stores elements. They're functional in nature, and it's worth noting that operations on a stream produce a result and typically return another stream, but do not modify its source.
To &quot;solidify&quot; the changes, you collect the elements of a stream back into a <code>Collection</code>.
<blockquote>
In this guide, we'll take a look at how to reduce elements through a downstream collector, with the help of Collectors.reducing().
</blockquote>
Reduction operations are one of the most common and powerful operations in Functional Programming. Additionally, you can reduce elements via the <code>reduce()</code> method - however, it's typically associated with reducing a collection to a single value. <code>reducing()</code> on the other hand is associated with collecting a stream into a list of reduced values instead.

 <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: Both approaches can be used to produce lists of reduced values, as well. In general - you'll use <code>map()</code> and <code>reduce()</code> if you're reducing a stream from the get-go into a result, and you'll use <code>reducing()</code> as a downstream collector within an operation pipeline with other collectors and operations.

 </div>
 </div>
 </div>
 <blockquote>
If you'd like to read more about <code>reduce()</code> - read our <a target="_blank" href="https://stackabuse.com/java-8-streams-guide-to-reduce/">Java 8 Streams: Definitive Guide to reduce()</a>!
</blockquote>
<h2 id="collectorsandstreamcollect">Collectors and Stream.collect()</h2>
Collectors represent implementations of the <code>Collector</code> interface, which implements various useful reduction operations, such as accumulating elements into collections, summarizing elements based on a specific parameter, etc.
<blockquote>
All predefined implementations can be found within the <code>Collectors</code> class.
</blockquote>
You can also very easily implement your own collector and use it instead of the predefined ones, though - you can get pretty far with the built-in collectors, as they cover the vast majority of cases in which you might want to use them.
To be able to use the class in our code we need to import it:
<pre><code class="hljs">import static java.util.stream.Collectors.*;
</code></pre>
<code>Stream.collect()</code> performs a mutable reduction operation on the elements of the stream.

 <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">
 A mutable reduction operation collects input elements into a mutable container, such as a <code>Collection</code>, as it processes the elements of the stream.

 </div>
 </div>
 </div>
 <h2 id="guidetocollectorsreducing">Guide to Collectors.reducing()</h2>
Within the <code>Collectors</code> class is a vast number of methods, allowing us to collect streams in a myriad of ways. As reduction is a very common operation - it offers a reduction method that operates on all the elements of a stream - returning their reduced variants.
There are three different overloaded variants of this method. They differ from each other by the number of arguments they take in, what those arguments do, as well as the return value. We'll be discussing them all separately in detail as we go along in this guide.
The arguments are the exact ones you'd expect from a reduction operation, and exactly the same ones <code>reduce()</code> uses:
<pre><code class="hljs">public static &lt;T&gt; Collector&lt;T,?,Optional&lt;T&gt;&gt; reducing(BinaryOperator&lt;T&gt; op)
 
public static &lt;T&gt; Collector&lt;T,?,T&gt; reducing(T identity, BinaryOperator&lt;T&gt; op)
 
public static &lt;T,U&gt; Collector&lt;T,?,U&gt; reducing(U identity,
 Function&lt;? super T,? extends U&gt; mapper,
 BinaryOperator&lt;U&gt; op)
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: The generic <code>T</code> in the method signatures represents the type of the input elements we're working with. The generic <code>U</code> in the third method signature represents the type of the mapped values.

 </div>
 </div>
 </div>
 In essence - you're dealing with the identity, mapper and combiner. The identity is the value that, when applied to itself, returns the same value. The mapper maps objects we're reducing to another value - commonly being one of the fields of the object. A combiner, well, combines the results into the final result returned to the user.
The <code>reducing()</code> collector is most useful when used in a multi-level reduction operation, downstream of <code>groupingBy()</code> or <code>partitioningBy()</code>. Otherwise, we could reasonably substitute it with <code>Stream.map()</code> and <code>Stream.reduce()</code> to perform a simple map-reduce on a stream instead.
<blockquote>
If you're unfamiliar with these two collectors, read our <a target="_blank" href="https://stackabuse.com/guide-to-java-8-collectors-groupingby/">Guide to Java 8 Collectors: groupingBy()</a> and <a target="_blank" href="https://stackabuse.com/java-8-streams-definitive-guide-to-partitioningby/">Guide to Java 8 Collectors: partitioningBy()</a>!
</blockquote>
Before we jump in and cover the different overloads of <code>reducing()</code>, let's go ahead and define a <code>Student</code> class that we'll be reducing in the upcoming examples:
<pre><code class="hljs">public class Student {
 private String name;
 private String city;
 private double avgGrade;
 private int age;
 
 // Constructor, getters, setters and toString()
}
</code></pre>
Let's also instantiate our students in a <code>List</code>:
<pre><code class="hljs">List&lt;Student&gt; students = Arrays.asList(
 new Student(&quot;John Smith&quot;, &quot;Miami&quot;, 7.38, 19),
 new Student(&quot;Mike Miles&quot;, &quot;New York&quot;, 8.4, 21),
 new Student(&quot;Michael Peterson&quot;, &quot;New York&quot;, 7.5, 20),
 new Student(&quot;James Robertson&quot;, &quot;Miami&quot;, 9.1, 20),
 new Student(&quot;Joe Murray&quot;, &quot;New York&quot;, 7.9, 19),
 new Student(&quot;Kyle Miller&quot;, &quot;Miami&quot;, 9.83, 20)
);
</code></pre>
<h2 id="collectorsreducingwithabinaryoperator">Collectors.reducing() with a BinaryOperator</h2>
The first overload of the <code>reducing()</code> method takes in only one parameter - <code>BinaryOperator&lt;T&gt; op</code>. This parameter, as the name implies, represents an operation used to reduce the input elements.
A <code>BinaryOperator</code> is a functional interface so it can be used as the assignment target for a lambda expression or a method reference. Natively, <code>BinaryOperator</code> has two methods - <code>maxBy()</code> and <code>minBy()</code> both of which take a <code>Comparator</code>. The return value of these two methods is a <code>BinaryOperator</code> that returns the greater/lesser of the two elements.
<blockquote>
In simpler terms - it accepts two inputs, and returns one output, based on some criteria.
</blockquote>
<blockquote>
If you'd like to read more about Functional Interfaces and Lambda Expressions - read our <a target="_blank" href="https://stackabuse.com/guide-to-functional-interfaces-and-lambda-expressions-in-java/">Guide to Functional Interfaces and Lambda Expressions in Java</a>!
</blockquote>
Let's assume that from within our <code>List</code> of students we want to find the student with the best and worst grades in their respective city. We'll first need to use a collector that accepts another downstream collector, such as the <code>partitioningBy()</code> or <code>groupingBy()</code> collectors, after which we'll use the <code>reducing()</code> method to perform the required reduction.
Of course, we could also reduce them from the get-go via <code>Stream.reduce()</code> without grouping them first:
<pre><code class="hljs">Map&lt;String, Optional&lt;Student&gt;&gt; reduceByCityAvgGrade = students.stream()
 .collect(Collectors
 .groupingBy(Student::getCity,
 Collectors.reducing(BinaryOperator
 .maxBy(Comparator
 .comparing(Student::getAvgGrade)))));
</code></pre>
The student <code>List</code> is transformed into a <code>Stream</code> using the <code>stream()</code> method, after which we collect the grouped elements into groups, <code>reducing()</code> the list of students in each city to a single student in each city with the highest grade. This variant of the method always returns a <code>Map&lt;T, Optional&lt;T&gt;&gt;</code>.
After running this code, we get the following output:
<pre><code class="hljs">{
New York=Optional[Student{name=&#x27;Mike Miles&#x27;, city=&#x27;New York&#x27;, avgGrade=8.4, age=21}], Miami=Optional[Student{name=&#x27;Kyle Miller&#x27;, city=&#x27;Miami&#x27;, avgGrade=9.83, age=20}]
}
</code></pre>
<h2 id="collectorsreducingwithabinaryoperatorandidentity">Collectors.reducing() with a BinaryOperator and Identity</h2>
In the previous code sample - the result is wrapped in an optional. If there is no value - an <code>Optional.empty()</code> is returned instead. This is because there is no default value that can be used instead.
To deal with this, and remove the <code>Optional</code> wrapping, we can use the second variant of the <code>reducing()</code> overload, the one that takes in two arguments - a <code>BinaryOperator</code> and an <code>Identity</code>. The <code>Identity</code> represents the value for the reduction, and also the value that is returned when there are no input elements!
This time around, we pass in a 'default' value that kicks in if a value isn't present, and is used as the identity of the result:
<pre><code class="hljs">Map&lt;String, Student&gt; reduceByCityAvgGrade = students.stream()
 .collect(Collectors
 .groupingBy(Student::getCity,
 Collectors.reducing(new Student(&quot;x&quot;, &quot;x&quot;, 0.0, 0),
 BinaryOperator.maxBy(Comparator
 .comparing(Student::getAvgGrade)))));
</code></pre>
In our case, for <code>Identity</code> we use a new <code>Student</code> object. The <code>name</code>, <code>city</code> and <code>age</code> fields have no impact on our result while using the <code>reducing()</code> method, so it doesn't really matter what we put as these three values. However, as we are reducing our input data by the <code>avgGrade</code> field, that one matters. Any value that can be logically correct here is valid.
We've put a <code>0.0</code> grade as the default one, with <code>&quot;x&quot;</code> for the name and city, denoting an empty result. The lowest grade can be <code>6.0</code> so <code>0.0</code> and the missing name signals an empty value - but we can actually expect <code>Student</code> objects instead of Optionals now:
<pre><code class="hljs">{
New York=Student{name=&#x27;Mike Miles&#x27;, city=&#x27;New York&#x27;, avgGrade=8.4, age=21},
Miami=Student{name=&#x27;Kyle Miller&#x27;, city=&#x27;Miami&#x27;, avgGrade=9.83, age=20}
}
</code></pre>
<h2 id="collectorsreducingwithabinaryoperatoridentityandmapper">Collectors.reducing() with a BinaryOperator, Identity and Mapper</h2>
The last of the three overloaded variants takes in one extra argument in addition to the previous two - a mapper. This argument represents a mapping function to apply to each element.
You don't have to group by a city to perform the <code>reducing()</code> operation:
<pre><code class="hljs">double largestAverageGrade = students.stream()
 .collect(Collectors.reducing(0.0, Student::getAvgGrade,
 BinaryOperator.maxBy(Comparator.comparingDouble(value -&gt; value))));
</code></pre>
This would return <code>9.83</code>, which in fact is the largest value assigned of all of the <code>avgGrade</code> fields assigned to all of the student objects within the <code>List</code>. However, if you're using an IDE or tool that detects code-smell, you'll quickly get recommended to change the above line into the following:
<pre><code class="hljs">double largestAverageGrade = students.stream()
 .map(Student::getAvgGrade)
 .reduce(0.0, BinaryOperator.maxBy(Comparator.comparingDouble(value -&gt; value)));
</code></pre>
<blockquote>
<code>map()</code> and <code>reduce()</code> is preferred if you're not really doing anything else. <code>reducing()</code> is preferred as a downstream collector.
</blockquote>
With a mapper - you can map the values you've reduced to something else. Commonly, you'll map objects to one of their fields. We can map <code>Student</code> objects to their names, cities or grades, for instance. In the following code snippet, we'll group students by their city, reduce each city list based on their grades to the highest-grade student, and then map this student to their grade, resulting in a single value per city:
<pre><code class="hljs">Map&lt;String, Double&gt; reduceByCityAvgGrade1 = students.stream()
 .collect(Collectors
 .groupingBy(Student::getCity,
 Collectors.reducing(6.0, Student::getAvgGrade,
 BinaryOperator.maxBy(Comparator
 .comparingDouble(i-&gt;i)))));
</code></pre>
This gives us a slightly different output than we earlier had:
<pre><code class="hljs">{New York=8.4, Miami=9.83}
</code></pre>
Considering the amount of collectors you can use instead and chain this way - you can do a lot of work using just the built-in collectors and stream operations.
<h2 id="conclusion">Conclusion</h2>
In this guide we've covered the usage of the <code>reducing()</code> method from the <code>Collectors</code> class. We covered all three of its overloads and discussed their usages through practical examples.

Branko Ilic

In this guide, we'll take a look at how to use the Collectors.reducing() method through practical examples with Identity, BinaryOperation and a Mapper and compare it to the Stream.reduce() method.