Mehreen Saeed

In this tutorial, we'll go over the theory on how does gradient descent work and how to implement it in Python. Then, we'll implement batch and stochastic gradient descent to minimize Mean Squared Error functions.

Gradient Descent in Python: Implementation and Theory

<h2 id="introduction">Introduction</h2>
The term slicing in programming usually refers to obtaining a substring, sub-tuple, or sublist from a string, tuple, or list respectively.
Python offers an array of straightforward ways to slice not only these three but any iterable. An iterable is, as the name suggests, any object that can be iterated over.
In this article, we'll go over everything you need to know about Slicing Tuples in Python.
<h2 id="slicingatupleinpython">Slicing a Tuple in Python</h2>
There are a couple of ways to slice a tuple, most common of which is by using the <code>:</code> operator with the following syntax:
<pre><code class="hljs">tuple[start:end]
tuple[start:end:step]
</code></pre>
The <code>start</code> parameter represents the starting index, <code>end</code> is the ending index, and <code>step</code> is the number of items that are &quot;stepped&quot; over.
If <code>step</code> isn't explicitly given, the default value is <code>1</code>.
Let's go ahead and slice a tuple:
<pre><code class="hljs">a_tuple = (&#x27;You&#x27;, &#x27;can’t&#x27;, &#x27;stop&#x27;, &#x27;the&#x27;, &#x27;change,&#x27;, &#x27;any&#x27;, &#x27;more&#x27;, &#x27;than&#x27;, &#x27;you&#x27;, &#x27;can&#x27;, &#x27;stop&#x27;, &#x27;the&#x27;, &#x27;suns&#x27;, &#x27;from&#x27;, &#x27;setting.&#x27;)
subtuple = a_tuple[1:5]
print(subtuple)
</code></pre>
The resulting tuple will be:
<pre><code class="hljs">(&#x27;can’t&#x27;, &#x27;stop&#x27;, &#x27;the&#x27;, &#x27;change,&#x27;)
</code></pre>
<h3 id="findingthefirstandthelastnelementsofatuple">Finding the First and the Last n Elements of a Tuple</h3>
To find the first and last <code>n</code> elements of a tuple, we'll slice from the first element to <code>n</code> and then from <code>-n</code> to the end of the tuple.
<code>-n</code> will start counting from the end of the tuple, backwards, giving us the last <code>n</code> elements:
<pre><code class="hljs">n = 2
a_tuple = (&#x27;I&#x27;, &#x27;find&#x27;, &#x27;your&#x27;, &#x27;lack&#x27;, &#x27;of&#x27;, &#x27;faith&#x27;, &#x27;disturbing.&#x27;)

first_n_tuple = a_tuple[:n]
print(first_n_tuple)
last_n_tuple = a_tuple[-n:]
print(last_n_tuple)
</code></pre>
The resulting subtuples are:
<pre><code class="hljs">(&#x27;I&#x27;, &#x27;find&#x27;)
(&#x27;faith&#x27;, &#x27;disturbing.&#x27;)
</code></pre>
<h3 id="reversetuplewithslicenotation">Reverse Tuple with Slice Notation</h3>
If we set the <code>step</code> parameter to <code>-1</code>, it'll start stepping backwards. If we include the whole, or even a part of the tuple, and just step backwards, it'll effectively reverse the tuple's contents:
<pre><code class="hljs">a_tuple = (&#x27;Fear&#x27;, &#x27;is&#x27;, &#x27;the&#x27;, &#x27;path&#x27;, &#x27;to&#x27;, &#x27;the&#x27;, &#x27;dark&#x27;, &#x27;side.&#x27;, &#x27;Fear&#x27;, &#x27;leads&#x27;, &#x27;to&#x27;, &#x27;anger;&#x27;, &#x27;anger&#x27;, &#x27;leads&#x27;, &#x27;to&#x27;, &#x27;hate;&#x27;, &#x27;hate&#x27;, &#x27;leads&#x27;, &#x27;to&#x27;, &#x27;suffering.&#x27;, &#x27;I&#x27;, &#x27;sense&#x27;, &#x27;much&#x27;, &#x27;fear&#x27;, &#x27;in&#x27;, &#x27;you.&#x27;, 7)
reverse_tuple = a_tuple[::-1]
print(reverse_tuple)
</code></pre>
The reversed tuple will be:
<pre><code class="hljs">(7, &#x27;you.&#x27;, &#x27;in&#x27;, &#x27;fear&#x27;, &#x27;much&#x27;, &#x27;sense&#x27;, &#x27;I&#x27;, &#x27;suffering.&#x27;, &#x27;to&#x27;, &#x27;leads&#x27;, &#x27;hate&#x27;, &#x27;hate;&#x27;, &#x27;to&#x27;, &#x27;leads&#x27;, &#x27;anger&#x27;, &#x27;anger;&#x27;, &#x27;to&#x27;, &#x27;leads&#x27;, &#x27;Fear&#x27;, &#x27;side.&#x27;, &#x27;dark&#x27;, &#x27;the&#x27;, &#x27;to&#x27;, &#x27;path&#x27;, &#x27;the&#x27;, &#x27;is&#x27;, &#x27;Fear&#x27;)
</code></pre>
<h3 id="findingeverynthelementofatuple">Finding Every n-th Element of a Tuple</h3>
To find every <code>n</code>-th element of a tuple, we'll jump over all non-<code>n</code> elements by setting the step to be <code>n</code>:
<pre><code class="hljs">n = 5
a_tuple = (&#x27;The&#x27;, &#x27;dark&#x27;, &#x27;side&#x27;, &#x27;of&#x27;, &#x27;the&#x27;, &#x27;Force&#x27;, &#x27;is&#x27;, &#x27;a&#x27;, &#x27;pathway&#x27;, &#x27;to&#x27;, &#x27;many&#x27;, &#x27;abilities&#x27;, &#x27;some&#x27;, &#x27;consider&#x27;, &#x27;to&#x27;, &#x27;be&#x27;, &#x27;unnatural.&#x27;)
replaced_tuple = a_tuple[::n]
print(replaced_tuple)
</code></pre>
This will result in a tuple:
<pre><code class="hljs">(&#x27;The&#x27;, &#x27;Force&#x27;, &#x27;many&#x27;, &#x27;be&#x27;)
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Slicing any sequence in Python is easy, simple, and intuitive. Negative indexing offers an easy way to acquire the first or last few elements of a sequence, or reverse its order.
In this article, we've covered how to apply the Slice Notation on Tuples in Python.

Kristina Popovic

In this article, we'll cover examples of how to use the slice notation on tuples in Python. We'll slice a tuple, find the first and last n elements, reverse a tuple and skip over n elements.

Python: Slice Notation on Tuple

<h2 id="introduction">Introduction</h2>
A list is the most flexible data structure in Python. Whereas, a 2D list which is commonly known as a list of lists, is a list object where every item is a list itself - for example: <code>[[1,2,3], [4,5,6], [7,8,9]]</code>.
Flattening a list of lists entails converting a 2D list into a 1D list by un-nesting each list item stored in the list of lists - i.e., converting <code>[[1, 2, 3], [4, 5, 6], [7, 8, 9]]</code> into <code>[1, 2, 3, 4, 5, 6, 7, 8, 9] </code>.
The process of flattening can be performed using nested for loops, list comprehensions, recursion, built-in functions or by importing libraries in Python depending on the regularity and depth of the nested lists.
<h2 id="typesofnestedlists">Types of Nested Lists</h2>
Since Python is weakly typed, you can encounter regular and irregular lists of lists.
<h3 id="regularlistoflists">Regular List of Lists</h3>
Every element of this list is a sublist, thereby adhering to the uniformity of the element type. 
Example: <code>[[1, 2, 3], [4, 5, 6], [7, 8, 9]]</code> is a regular list of lists as <code>[1, 2, 3], [4, 5, 6], [7, 8, 9]</code> is of type <code>list</code>.
<h3 id="irregularlistoflists">Irregular List of Lists</h3>
Every element of this list is either a sublist or a non-list item (for example an integer or string). Therefore, there is an irregularity in terms of the element type. Example: <code>[[1, 2, 3], [4, 5], 6] </code> where <code>[1, 2, 3]</code> and <code>[4, 5]</code> are of type <code>list</code> and <code>6</code> is of type <code>int</code>.
<h2 id="flattenlistoflistsusingnestedforloops">Flatten List of Lists Using Nested for Loops</h2>
This is a brute force approach to obtaining a flat list by picking every element from the list of lists and putting it in a 1D list.
The code is intuitive as shown below and works for both regular and irregular lists of lists:
<pre><code class="hljs">def flatten_list(_2d_list):
 flat_list = []
 # Iterate through the outer list
 for element in _2d_list:
 if type(element) is list:
 # If the element is of type list, iterate through the sublist
 for item in element:
 flat_list.append(item)
 else:
 flat_list.append(element)
 return flat_list

nested_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
print(&#x27;Original List&#x27;, nested_list)
print(&#x27;Transformed Flat List&#x27;, flatten_list(nested_list))
</code></pre>
This results in:
<pre><code class="hljs">Original List [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
Transformed Flat List [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
</code></pre>
<h2 id="flattenlistoflistsusingalistcomprehension">Flatten List of Lists Using a List Comprehension</h2>
This approach provides an elegant but a less intuitive solution to create a flat list based on an existing 2D list:
<pre><code class="hljs">regular_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9]]
flat_list = [item for sublist in regular_list for item in sublist]
print(&#x27;Original list&#x27;, regular_list)
print(&#x27;Transformed list&#x27;, flat_list)
</code></pre>
Which would output the following:
<pre><code class="hljs">Original list [[1, 2, 3, 4], [5, 6, 7], [8, 9]]
Transformed list [1, 2, 3, 4, 5, 6, 7, 8, 9]
</code></pre>
<h2 id="flattenlistoflistsrecursively">Flatten List of Lists Recursively</h2>
The 2D list can be flattened recursively as well. The implementation below works both for regular and irregular list of lists:
<pre><code class="hljs">def flatten(list_of_lists):
 if len(list_of_lists) == 0:
 return list_of_lists
 if isinstance(list_of_lists[0], list):
 return flatten(list_of_lists[0]) + flatten(list_of_lists[1:])
 return list_of_lists[:1] + flatten(list_of_lists[1:])


print(flatten([[1, 2, 3, 4], [5, 6, 7], [8, 9], 10]))
</code></pre>
Which would give us:
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
</code></pre>
<h2 id="usinglibraries">Using Libraries</h2>
You can also rely on the help of Python libraries for this task.
<h3 id="flattenlistoflistsusingfunctoolsreduceandiconcat">Flatten List of Lists Using functools (reduce() and iconcat())</h3>
The <code>iconcat()</code> function performs the basic operation of concatenation and is applied cumulatively to the items of a list of lists, from left to right, so as to reduce it to a single list:
<pre><code class="hljs">import functools
import operator
regular_list = []

# Transform an irregular 2D list into a regular one.
def transform(nested_list):
 for ele in nested_list:
 if type(ele) is list:
 regular_list.append(ele)
 else:
 regular_list.append([ele])
 return regular_list


irregular_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10], 11]
regular_2D_list = transform(irregular_list)
print(&#x27;Original list&#x27;, irregular_list)
print(&#x27;Transformed list&#x27;, functools.reduce(operator.iconcat, regular_2D_list, []))
</code></pre>
Which would give us the desired result:
<pre><code class="hljs">Original list [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10], 11]
Transformed list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
</code></pre>
<h3 id="flattenlistoflistsusingitertoolschain">Flatten List of Lists Using itertools (chain())</h3>
This approach is ideal for transforming a 2-D list into a single flat list as it treats consecutive sequences as a single sequence by iterating through the iterable passed as the argument in a sequential manner.
<pre><code class="hljs">import itertools

regular_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
flat_list = list(itertools.chain(*regular_list))

print(&#x27;Original list&#x27;, regular_list)
print(&#x27;Transformed list&#x27;, flat_list)
</code></pre>
Again, this would give us a flattened list as the output:
<pre><code class="hljs">Original list [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
Transformed list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
</code></pre>
<h3 id="flattenlistoflistsusingnumpyconcatenateandflat">Flatten List of Lists Using numpy (concatenate() and flat())</h3>
Numpy offers common operations which include concatenating regular 2D arrays row-wise or column-wise. We are also using the <code>flat</code> attribute to get a 1D iterator over the array in order to achieve our goal. However, this approach is relatively slow:
<pre><code class="hljs">import numpy

regular_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9]]

flat_list = list(numpy.concatenate(regular_list).flat)

print(&#x27;Original list&#x27;, regular_list)
print(&#x27;Transformed list&#x27;, flat_list)
</code></pre>
Which gives us the desired output:
<pre><code class="hljs">Original list [[1, 2, 3, 4], [5, 6, 7], [8, 9]]
Transformed list [1, 2, 3, 4, 5, 6, 7, 8, 9]
</code></pre>
<h2 id="usingbuiltinfunctions">Using Built-In Functions</h2>
The task of flattening can also be performed by using built-in functions that Python offers.
<h3 id="flattenlistoflistsusingsum">Flatten List of Lists Using sum</h3>
Summing over inner lists is another solution. The function has two parameters: <code>iterable</code> which is a list of lists and <code>start</code> which is an empty list in our case that serves as the initial flat list to which items of the inner sublists are added.
This approach is convenient as you don't have to import anything but it's slower than <code>itertools()</code> and the <code>chain()</code> functions when the number of sublists is large:
<pre><code class="hljs">regular_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9]]

flat_list = sum(regular_list, [])

print(&#x27;Original list&#x27;, regular_list)
print(&#x27;Transformed list&#x27;, flat_list)
</code></pre>
With the output:
<pre><code class="hljs">Original list [[1, 2, 3, 4], [5, 6, 7], [8, 9]]
Transformed list [1, 2, 3, 4, 5, 6, 7, 8, 9]
</code></pre>
<h3 id="flattenlistoflistsusinglambda">Flatten List of Lists Using Lambda</h3>
An anonymous function can be defined using the lambda keyword. The regular/irregular list is passed as the argument to this anonymous function and the evaluation of the expression is done to obtain a flat 1D list:
<pre><code class="hljs">irregular_list = [[1, 2, 3], [3, 6, 7], [7, 5, 4],7]

# Using lambda arguments: expression
flatten_list = lambda irregular_list:[element for item in irregular_list for element in flatten_list(item)] if type(irregular_list) is list else [irregular_list]

print(&quot;Original list &quot;, irregular_list)
print(&quot;Transformed List &quot;, flatten_list(irregular_list))
</code></pre>
We would again get the desired result:
<pre><code class="hljs">Original list [[1, 2, 3], [3, 6, 7], [7, 5, 4], 7]
Transformed List [1, 2, 3, 3, 6, 7, 7, 5, 4, 7]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we provided an extensive list of ways we can complete the task of flattening a list of lists in Python.

Raksha Shenoy

In this tutorial, we'll go over examples of how to flatten a 2D (list of lists) list into one list. We'll use for loops, list comprehensions, recursive algorithms, as well as libraries like Numpy and functools.

Python: How to Flatten List of Lists

Python: How to Flatten a List of Lists

<h2 id="introduction">Introduction</h2>
Searching, in the context of Computer Science, is the process of locating a particular element in the given list/array. If we pay close attention, we can find search algorithms everywhere.
Consider the process of logging into a website. Entered email and password are searched against the existing key-value pairs in the database to validate the user.
In this article, let us look at the most basic algorithm to search through a given list of elements - Linear Search.
<h2 id="understandinglinearsearch">Understanding Linear Search</h2>
The Linear Search algorithm is a set of instructions to traverse the given list and check every element in the list until we find whatever element we are looking for. The technical term for the element we are looking for is - key.
The algorithm goes from the leftmost (or starting) element and continues searching until it either finds the desired element or goes through all the elements in the list.
If the element is found, we will return the position (or <code>index</code>) of the element. If the element we are looking for doesn't exist in the list, we generally return <code>-1</code>.
<h2 id="implementationoflinearsearchinjavascript">Implementation of Linear Search in JavaScript</h2>
We can traverse through the given list using a <code>for</code> loop. Let's look at the implementation of Linear Search:
<pre><code class="hljs">function linearSearch(arr, key){
 for(let i = 0; i &lt; arr.length; i++){
 if(arr[i] === key){
 return i
 }
 }
 return -1
}
</code></pre>
Here we are going through all the elements in an array and comparing each element with the key. If we find a match, we return the index of the element. In our case, the variable <code>i</code> keeps track of where we are in the array, and if we find a match, we return the current value for <code>i</code>.
In case the element doesn't exist in our list, the <code>linearSearch</code> function won't return any <code>i</code> value from the loop. We just <code>return -1</code> after the loop to show that the function didn't find the desired element.
<h2 id="globallinearsearch">Global Linear Search</h2>
In the previous implementation, we return a value after we come across the first occurrence of the element we are looking for (<code>key</code>). But what if we want to the indices of all the occurrences of a given element?
That's where global linear search comes in. It is a variant of linear search where we are looking for multiple occurrences of a given element.
Let's look at the implementation of the global linear search:
<pre><code class="hljs">function globalLinearSearch(arr, key){
 let results = []
 for(let i = 0; i &lt; arr.length; i++){
 if(arr[i] === key){
 results.push(i)
 }
 }
 // If results array is empty, return -1
 if(!results){
 return -1
 }

 return results
}
</code></pre>
In this case, instead of immediately returning the index of the matching element, we are storing it in an array. In the end, we are returning the array of indices.
<h2 id="theefficiencyoflinearsearch">The Efficiency of Linear Search</h2>
Linear Search is a classic example of a brute-force algorithm. This means that the algorithm doesn't use any logic to try and do what it's supposed to quickly, or to somehow reduce the range of elements in which it searches for <code>key</code>. Other search algorithms aim to do this more efficiently by some sort of preprocessing of the list/array, for example sorting it.
The time complexity of Linear Search is O(n), where n is the number of elements in the list we're searching. This is because we always consider the worst-case while calculating the time complexity. In the case of Linear Search (as with most search algorithms) the worst-case occurs when the element doesn't exist in the list. In this situation, we'd need to go through all the n elements to determine that the element isn't there.
<h2 id="conclusion">Conclusion</h2>
In this article, we have seen the logic behind linear search, and then using that knowledge, we implemented the algorithm in JavaScript. We have also looked at the time complexity for the linear search algorithm.
It's by far the simples search algorithm, one that doesn't use any logic to try and discard a particular range for searching or with a focus on speed.

Abhilash Kakumanu

In this article, we'll take a look at one of the simplest search algorithms - Linear Search in JavaScript. We'll implement regular as well as linear search for all occurrences of an element.

Linear Search in JavaScript

<h2 id="introduction">Introduction</h2>
Matplotlib is one of the most widely used data visualization libraries in Python. Much of Matplotlib's popularity comes from its customization options - you can tweak just about any element from its hierarchy of objects.
In this tutorial, we'll take a look at how to change the tick frequency in Matplotlib. We'll do this on the figure-level as well as the axis-level.
<h2 id="howtochangetickfrequencyinmatplotlib">How to Change Tick Frequency in Matplotlib?</h2>
Let's start off with a simple plot. We'll plot two lines, with random values:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

fig = plt.subplots(figsize=(12, 6))

x = np.random.randint(low=0, high=50, size=100)
y = np.random.randint(low=0, high=50, size=100)

plt.plot(x, color=&#x27;blue&#x27;)
plt.plot(y, color=&#x27;black&#x27;)

plt.show()
</code></pre>
<code>x</code> and <code>y</code> range from 0-50, and the length of these arrays is 100. This means, we'll have 100 data points for each of them. Then, we just plot this data onto the <code>Axes</code> object and show it via the PyPlot instance <code>plt</code>:
<img src="https://stackabuse.s3.amazonaws.com/media/change-tick-frequency-in-matplotlib-1.png" alt="plot random line plot in matplotlib">
Now, the frequency of the ticks on the X-axis is 20. They're automatically set to a frequency that seems fitting for the dataset we provide.
Sometimes, we'd like to change this. Maybe we want to reduce or increase the frequency. What if we wanted to have a tick on every 5 steps, not 20?
The same goes for the Y-axis. What if the distinction on this axis is even more crucial, and we'd want to have each tick on every step?
<h3 id="settingfigureleveltickfrequencyinmatplotlib">Setting Figure-Level Tick Frequency in Matplotlib</h3>
Let's change the figure-level tick frequency. This means that if we have multiple <code>Axes</code>, the ticks on all of these will be uniform and will have the same frequency:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

fig = plt.subplots(figsize=(12, 6))

x = np.random.randint(low=0, high=50, size=100)
y = np.random.randint(low=0, high=50, size=100)

plt.plot(x, color=&#x27;blue&#x27;)
plt.plot(y, color=&#x27;black&#x27;)

plt.xticks(np.arange(0, len(x)+1, 5))
plt.yticks(np.arange(0, max(y), 2))

plt.show()
</code></pre>
You can use the <code>xticks()</code> and <code>yticks()</code> functions and pass in an array denoting the actual ticks. On the X-axis, this array starts on <code>0</code> and ends at the length of the <code>x</code> array. On the Y-axis, it starts at <code>0</code> and ends at the max value of <code>y</code>. You can hard code the variables in as well.
The final argument is the <code>step</code>. This is where we define how large each step should be. We'll have a tick at every <code>5</code> steps on the X-axis and a tick on every <code>2</code> steps on the Y-axis:
<img src="https://stackabuse.s3.amazonaws.com/media/change-tick-frequency-in-matplotlib-2.png" alt="change figure-level tick frequency matplotlib">
<h3 id="settingaxisleveltickfrequencyinmatplotlib">Setting Axis-Level Tick Frequency in Matplotlib</h3>
If you have multiple plots going on, you might want to change the tick frequency on the axis-level. For example, you'll want rare ticks on one graph, while you want frequent ticks on the other.
You can use the <code>set_xticks()</code> and <code>set_yticks()</code> functions on the returned <code>Axes</code> instance when adding subplots to a <code>Figure</code>. Let's create a <code>Figure</code> with two axes and change the tick frequency on them separately:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

fig = plt.figure(figsize=(12, 6))

ax = fig.add_subplot(121)
ax2 = fig.add_subplot(122)

x = np.random.randint(low=0, high=50, size=100)
y = np.random.randint(low=0, high=50, size=100)
z = np.random.randint(low=0, high=50, size=100)

ax.plot(x, color=&#x27;blue&#x27;)
ax.plot(y, color=&#x27;black&#x27;)
ax2.plot(y, color=&#x27;black&#x27;)
ax2.plot(z, color=&#x27;green&#x27;)

ax.set_xticks(np.arange(0, len(x)+1, 5))
ax.set_yticks(np.arange(0, max(y), 2))
ax2.set_xticks(np.arange(0, len(x)+1, 25))
ax2.set_yticks(np.arange(0, max(y), 25))

plt.show()
</code></pre>
Now, this results in:
<img src="https://stackabuse.s3.amazonaws.com/media/change-tick-frequency-in-matplotlib-3.png" alt="change axis-level tick frequency in matplotlib">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to change the tick frequency in Matplotlib both on the figure-level as well as the axis-level.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Become dangerous with Data Visualization
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with these libraries - from simple plots to animated 3D plots with interactive buttons.
<blockquote>
It serves as an in-depth guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
</blockquote>
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, covers core plotting libraries like Matplotlib and Seaborn, and shows you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.
</blockquote>

David Landup

In this tutorial, we'll go over how to change the tick frequency in Matplotlib, both for the entire figure as well as axis-level tick frequency customization with examples.

Change Tick Frequency in Matplotlib

<h2 id="introduction">Introduction</h2>
Introduced in Java 8, the Stream API is commonly used for filtering, mapping and iterating over elements. When working with streams, one of the common tasks is finding duplicate elements.
In this tutorial, we'll be covering several ways to find duplicate elements in a Java Stream.
<h2 id="collectorstoset">Collectors.toSet()</h2>
The easiest way to find duplicate elements is by adding the elements into a <code>Set</code>. <code>Set</code>s can't contain duplicate values, and the <code>Set.add()</code> method returns a <code>boolean</code> value which is the result of the operation. If an element isn't added, <code>false</code> is returned, and vice versa.
Let's make a <code>Stream</code> of <code>String</code>s with some duplicate values. These values are checked via the <code>equals()</code> method, so make sure to have an adequately implemented one for custom classes:
<pre><code class="hljs">Stream&lt;String&gt; stream = Stream.of(&quot;john&quot;, &quot;doe&quot;, &quot;doe&quot;, &quot;tom&quot;, &quot;john&quot;);
</code></pre>
Now, let's make a <code>Set</code> to store the filtered items. We'll use the <code>filter()</code> method to filter out duplicate values and return them:
<pre><code class="hljs">Set&lt;String&gt; items = new HashSet&lt;&gt;();

stream.filter(n -&gt; !items.add(n))
 .collect(Collectors.toSet())
 .forEach(System.out::println);
</code></pre>
Here, we try to <code>add()</code> each element to the <code>Set</code>. If it's not added, due to it being duplicate, we collect that value and print it out:
<pre><code class="hljs">john
doe
</code></pre>
<h2 id="collectorstomap">Collectors.toMap()</h2>
Alternatively, you can also count the occurrences of duplicate elements and keep that information in a map that contains the duplicate elements as keys and their frequency as values.
Let's create a <code>List</code> of <code>Integer</code> type:
<pre><code class="hljs">List&lt;Integer&gt; list = Arrays.asList(9, 2, 2, 7, 6, 6, 5, 7);
</code></pre>
Then, let's collect the elements into a <code>Map</code> and count their occurrences:
<pre><code class="hljs">Map&lt;Integer, Integer&gt; map = list.stream()
 .collect(Collectors.toMap(Function.identity(), value -&gt; 1, Integer::sum));
 
System.out.println(map);
</code></pre>
We haven't removed any elements, just counted their occurrences and stored them into a <code>Map</code>:
<pre><code class="hljs">{2=2, 5=1, 6=2, 7=2, 9=1}
</code></pre>
<h2 id="collectorsgroupingbyfunctionidentitycollectorscountingwithcollectorstolist">Collectors.groupingBy(Function.identity(), Collectors.counting()) with Collectors.toList()</h2>
The <code>Collectors.groupingBy()</code> method is used for grouping elements, based on some property, and returning them as a <code>Map</code> instance.
In our case, the method receives two parameters - <code>Function.identity()</code>, that always returns its input arguments and <code>Collectors.counting()</code>, that counts the elements passed in the stream.
Then, we'll use the <code>groupingBy()</code> method to create a map of the frequency of these elements. After that, we can simply <code>filter()</code> the stream for elements that have a frequency higher than <code>1</code>:
<pre><code class="hljs">list.stream()
 // Creates a map {4:1, 5:2, 7:2, 8:2, 9:1}
 .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
 .entrySet()
 // Convert back to stream to filter
 .stream()
 .filter(element -&gt; element.getValue() &gt; 1)
 // Collect elements to List and print out the values
 .collect(Collectors.toList())
 .forEach(System.out::println);
</code></pre>
This results in:
<pre><code class="hljs">5=2
7=2
8=2
</code></pre>
If you'd like to extract just the duplicate elements, without their frequency, you can throw in an additional <code>map()</code> into the process. After filtering, and before collecting to a list, we'll get only the keys:
<pre><code class="hljs">.map(Map.Entry::getKey)
</code></pre>
<h2 id="collectionsfrequency">Collections.frequency()</h2>
<code>Collections.frequency()</code> is another method that comes from the Java Collections class that counts the occurrences of a specified element in the input stream by traversing each element. It takes two parameters, the collection and the element whose frequency is to be determined.
Now, we'll <code>filter()</code> the stream for each element that has a <code>frequency()</code> larger than <code>1</code>:
<pre><code class="hljs">list.stream()
 .filter(i -&gt; Collections.frequency(list, i) &gt; 1)
 //Collect elements to a Set and print out the values 
 .collect(Collectors.toSet())
 .forEach(System.out::println);
</code></pre>
Here, we can either collect to a <code>Set</code> or to a <code>List</code>. If we collect to a list, it'll have all duplicate elements, so some may repeat. If we collect to a set, it'll have unique duplicate elements.
This results in:
<pre><code class="hljs">5
7
8
</code></pre>
<h2 id="streamdistinct">Stream.distinct()</h2>
The <code>distinct()</code> method is a stateful method (keeps the state of previous elements in mind) and compares elements using the <code>equals()</code> method. If they are distinct/unique, they're returned back, which we can populate into another list.
Let's make a list with some duplicate values and extract the distinct values:
<pre><code class="hljs">List&lt;String&gt; list = new ArrayList(Arrays.asList(&quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;D&quot;, &quot;A&quot;, &quot;B&quot;, &quot;C&quot;, &quot;A&quot;, &quot;F&quot;, &quot;C&quot;));

List&lt;String&gt; distinctElementList = list.stream()
 .distinct()
 .collect(Collectors.toList());
</code></pre>
Now, all non-distinct values have more than one occurrence. If we remove the distinct values, we'll be left with duplicate elements:
<pre><code class="hljs">for (String distinctElement : distinctElementList) {
 list.remove(distinctElement);
}
</code></pre>
Now, let's print out the results:
<pre><code class="hljs">list.forEach(System.out::print)
</code></pre>
These are the duplicate elements, with their respective occurrences:
<pre><code class="hljs">ABCAC
</code></pre>
If you'd like to sift through these as well, and only show one occurrence of each duplicate element (instead of all of them separately), you can run them through the <code>distinct()</code> method again:
<pre><code class="hljs">list.stream()
 .distinct()
 .collect(Collectors.toList())
 .forEach(System.out::print);
</code></pre>
This results in:
<pre><code class="hljs">ABC
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over a few approaches to finding duplicate elements in a Java Stream.
We've covered the <code>Stream.distinct()</code> method from the Stream API, the <code>Collectors.toSet()</code>, <code>Collectors.toMap()</code> and <code>Collectors.groupingBy()</code> methods from Java Collectors, as well as <code>Collections.frequency()</code> method from Collections framework.

Ilkyaz Altuntas

In this tutorial, we'll go over how to find duplicate elements in a Java Stream from a list, map or set. We'll use the Stream API, Collectors and Collections.

Java: Finding Duplicate Elements in a Stream

<h2 id="introduction">Introduction</h2>
Matplotlib is one of the most widely used data visualization libraries in Python. Much of Matplotlib's popularity comes from its customization options - you can tweak just about any element from its hierarchy of objects.
<blockquote>
In this tutorial, we'll take a look at how to set the axis range (<code>xlim</code>, <code>ylim</code>) in Matplotlib, to truncate or expand the view to specific limits. This can be useful when you want to focus on a particular portion of your data or to ensure consistency across multiple plots.
</blockquote>
<h2 id="creatingaplot">Creating a Plot</h2>
Let's first create a simple plot to work with:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

fig, ax = plt.subplots(figsize=(12, 6))

x = np.arange(0, 10, 0.1)
y = np.sin(x)
z = np.cos(x)

ax.plot(y, color=&#x27;blue&#x27;, label=&#x27;Sine wave&#x27;)
ax.plot(z, color=&#x27;black&#x27;, label=&#x27;Cosine wave&#x27;)

plt.show()
</code></pre>
In the above code, we create a figure and axis object with <code>plt.subplots()</code>, generate <code>x</code>, <code>y</code>, and <code>z</code> data points using NumPy, and then plot the sine and cosine waves on the same axis. Optionally, you could add <code>ax.legend()</code> to display the labels for each wave.
In this example, we've plotted the values created by applying a sine and cosine function to the sequence generated using <a target="_blank" href="https://stackabuse.com/guide-to-numpys-arange-function/">NumPy's arange() Function</a>. The sequence starts at <code>0</code> and ends at <code>10</code> with a step of <code>0.1</code>. Running this code produces the following plot:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-set-axis-range-xlim-ylim-in-matplotlib-1.png" alt="matplotlib plot subplots">
The x-axis currently ranges from <code>0</code> to <code>100</code>, and the y-axis ranges from <code>-1</code> to <code>1</code>. However, you might want to modify the axis range for better visualization or to focus on a specific region of the plot.
<h2 id="settingaxisrangeinmatplotlib">Setting Axis Range in Matplotlib</h2>
To adjust the axis range, you can use the <code>xlim</code> and <code>ylim</code> functions. These functions can be accessed either through the PyPlot instance or the <code>Axes</code> instance.
<h3 id="howtosetxlimitxliminmatplotlib">How to Set X-Limit (<code>xlim</code>) in Matplotlib</h3>
To set the x-axis range, you can use the <code>xlim</code> function, which takes two arguments: the lower and upper limits of the x-axis. For example, if you want to focus on the range from <code>2</code> to <code>8</code>, you can set the x-axis limits as follows:
Let's first set the X-limit using both the PyPlot and <code>Axes</code> instances. Both of these methods accept a tuple containing the left and right limits. For example, if we wanted to truncate the view to only show the data in the range of 25-50 on the X-axis, we'd use <code>xlim([25, 50])</code>:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

fig, ax = plt.subplots(figsize=(12, 6))

x = np.arange(0, 10, 0.1)
y = np.sin(x)
z = np.cos(x)

ax.plot(y, color=&#x27;blue&#x27;, label=&#x27;Sine wave&#x27;)
ax.plot(z, color=&#x27;black&#x27;, label=&#x27;Cosine wave&#x27;)

plt.xlim([25, 50])
plt.show()
</code></pre>
This code limits the view on the X-axis to the data between <code>25</code> and <code>50</code>, as shown in the resulting plot:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-set-axis-range-xlim-ylim-in-matplotlib-2.png" alt="how to set x limit axis range in matplotlib">
The same effect can be achieved by setting the limit via the <code>ax</code> object. This way, if we have multiple <code>Axes</code>, we can set the limit for them separately:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

fig = plt.figure(figsize=(12, 6))

x = np.arange(0, 10, 0.1)
y = np.sin(x)
z = np.cos(x)

ax = fig.add_subplot(121)
ax2 = fig.add_subplot(122)

ax.set_title(&#x27;Full view&#x27;)
ax.plot(y, color=&#x27;blue&#x27;, label=&#x27;Sine wave&#x27;)
ax.plot(z, color=&#x27;black&#x27;, label=&#x27;Cosine wave&#x27;)

ax2.set_title(&#x27;Truncated view&#x27;)
ax2.plot(y, color=&#x27;blue&#x27;, label=&#x27;Sine wave&#x27;)
ax2.plot(z, color=&#x27;black&#x27;, label=&#x27;Cosine wave&#x27;)

ax2.set_xlim([25, 50])

plt.show()
</code></pre>
In this example, the first subplot (<code>ax</code>) displays the full range of data, while the second subplot (<code>ax2</code>) has a truncated view of the data between <code>25</code> and <code>50</code> on the X-axis.
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-set-axis-range-xlim-ylim-in-matplotlib-3.png" alt="how to set x limit axis range for subplots in matplotlib">
<h3 id="howtosetylimityliminmatplotlib">How to Set Y-Limit (<code>ylim</code>) in Matplotlib</h3>
Now, let's set the Y-limit for better visualization and understanding of the data. This can be achieved with the same two approaches as we used for setting the X-limit:
<ol>
<li>Using <code>plt.ylim()</code> function:</li>
</ol>
<pre><code class="hljs">ax.plot(y, color=&#x27;blue&#x27;, label=&#x27;Sine wave&#x27;)
ax.plot(z, color=&#x27;black&#x27;, label=&#x27;Cosine wave&#x27;)

plt.ylim([-1, 0])
</code></pre>
<ol start="2">
<li>Using <code>ax.set_ylim()</code> method:</li>
</ol>
<pre><code class="hljs">ax.plot(y, color=&#x27;blue&#x27;, label=&#x27;Sine wave&#x27;)
ax.plot(z, color=&#x27;black&#x27;, label=&#x27;Cosine wave&#x27;)

ax.set_ylim([-1, 0])
</code></pre>
Both of these approaches result in the following graph with a customized Y-axis range:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-set-axis-range-xlim-ylim-in-matplotlib-4.png" alt="how to set y limit axis range in matplotlib">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over how to set the axis range (i.e., the X and Y limits) using Matplotlib in Python. Setting axis ranges can help improve the readability and understanding of your plots by focusing on the relevant data. Remember, you can use either the <code>plt.xlim()</code> and <code>plt.ylim()</code> functions or the <code>ax.set_xlim()</code> and <code>ax.set_ylim()</code> methods to achieve this customization.
If you're interested in Data Visualization and are unsure where to begin, we highly recommend our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Master the art of Data Visualization
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Regularly updated for free (latest update in April 2021) 
 ✅ Includes bonus resources and guides 
</div>
</div>
</a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a comprehensive book designed to guide absolute beginners with basic Python knowledge in mastering Pandas and Matplotlib. It builds a strong foundation for advanced work with these libraries, covering a wide range of plotting techniques - from simple 2D plots to animated 3D plots with interactive buttons.
<blockquote>
This in-depth guide will teach you everything you need to know about Pandas and Matplotlib, including how to create custom plot types that aren't readily available within the library itself.
</blockquote>
Data Visualization in Python, a book designed for beginner to intermediate Python developers, provides comprehensive guidance on data manipulation using Pandas and thoroughly explains core plotting libraries such as Matplotlib and Seaborn. Additionally, it delves into declarative and experimental libraries like Altair. Spanning 11 chapters, this book covers a total of 9 essential Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
This book serves as a unique, practical guide to Data Visualization, offering in-depth knowledge of a wide range of tools that you may encounter and utilize throughout your career. By learning how to effectively set axis ranges (<code>xlim</code>, <code>ylim</code>) in Matplotlib, you will be able to create visually appealing and informative plots, enhancing your data analysis and presentation skills.
</blockquote>

In this tutorial, we'll take a look at examples of how to set the axis range (xlim, ylim) also known as X limit and Y limit using Python's Matplotlib.

How to Set Axis Range (xlim, ylim) in Matplotlib

<h2 id="introduction">Introduction</h2>
Oftentimes, we are faced with a situation where we need to split a string at some specific character or substring, to derive some useful information from it.
For example, we might want to split a phone number on the country code or data imported from a CSV file.
In this article, we'll cover how to split a String in Java.
<h2 id="thesplitmethodwithoutalimit">The split() Method (Without a Limit)</h2>
This method takes one <code>String</code> parameter, in regular expression (regex) format. This method splits the string around the matches of the given regular expression.
The syntax for this method is:
<pre><code class="hljs">String[] split(String regex, int limit)
</code></pre>
Where the <code>regex</code> parameter represents the delimiter, i.e. based on what we'll split our string. Keep in mind that this parameter doesn't need to be anything complicated, Java simply provides the option of using regular expressions.
For example, let's see how we can split this String into two separate names:
<pre><code class="hljs">String myString = &quot;Jane-Doe&quot;;
String[] splitString = myString.split(&quot;-&quot;);
</code></pre>
We can simply use a character/substring instead of an actual regular expression. Of course, there are certain special characters in regex which we need to keep in mind, and escape them in case we want their literal value.
Once the string is split, the result is returned as an array of Strings. Strings in the returned array appear in the same order as in the original string.
The results are packed in the String array. To retrieve the separate names, we can access each element:
<pre><code class="hljs">System.out.println(splitString[0]);
System.out.println(splitString[1]);
</code></pre>
This results in:
<pre><code class="hljs">Jane
Doe
</code></pre>
Keep in mind, this method will split the string on all occurrences of the delimiter. For example, we can have a CSV formatted input:
<pre><code class="hljs">String myString = &quot;Jane,21,Employed,Software Engineer&quot;;
String[] splitString = myString.split(&quot;,&quot;);

for (String s : splitString) {
 System.out.println(s);
}
</code></pre>
This results in:
<pre><code class="hljs">Jane
21
Employed
Software Engineer
</code></pre>
<h2 id="javasplitmethodwithalimit">Java split() Method (With a Limit)</h2>
Here, the method takes on two parameters, one being the previously discussed <code>regex</code>, and the other being an integer value, denoting the <code>limit</code>. The <code>limit</code> parameter is used to decide how many times we want to split the string.
The <code>limit</code> parameter can take one of three forms, i.e it can either be greater than, less than or above zero. Let's take a look at what each of these situations represents:
<ul>
<li>A positive <code>limit</code> - The <code>String</code> will be split up to a maximum of <code>limit - 1</code> times. Beyond this, the rest of the string will be returned as the last element of the array, as it is, without splitting. The length of the returned array will always be less than or equal to <code>limit</code>.</li>
<li>A negative <code>limit</code> - The <code>String</code> is split at the delimiter as many times as possible, ignoring the particular negative value set. The substrings in the array include the trailing spaces in the original string, if there are any.</li>
<li>When the <code>limit</code> is set to <code>0</code> - The <code>String</code> is again split as many times as possible, and there is no limit on the length of the resulting array. This works the same as calling the <code>split()</code> method, with regex as the only argument, as seen earlier. In this case, trailing spaces are not returned.</li>
</ul>
<h3 id="positivelimitvalue">Positive Limit Value</h3>
Let's take a look at some examples of using different limits. Firstly, a positive <code>limit</code> value:
<pre><code class="hljs">String myString = &quot;there,,are,more,than,three,commas,,,&quot;;
String [] splitStrings = myString.split(&quot;,&quot;, 4);

for(String string : splitStrings){
 System.out.println(String.format(&quot; \&quot; %s \&quot;&quot;, string));
}
</code></pre>
With a limit of 4, the <code>String</code> will be split at most three (<code>limit - 1</code>) times. Which gives us an array with four elements (0..3), the last element being everything after the third split:
<pre><code class="hljs">&quot;there&quot;
&quot;&quot;
&quot;are&quot;
&quot;more,than,three,commas,,,&quot;
</code></pre>
If we used a negative <code>limit</code> on this same String:
<pre><code class="hljs">String myString = &quot;there,,are,more,than,three,commas,,,&quot;;
String [] splitStrings = myString.split(&quot;,&quot;, -1);

for(String string : splitStrings){
 System.out.println(String.format(&quot; \&quot; %s \&quot;&quot;, string));
}
</code></pre>
The <code>String</code> will be split as many times as possible, and the trailing empty strings would be added to the array:
<pre><code class="hljs">&quot;there&quot;
&quot;&quot;
&quot;are&quot;
&quot;more&quot;
&quot;than&quot;
&quot;three&quot;
&quot;commas&quot;
&quot;&quot;
&quot;&quot;
&quot;&quot;
</code></pre>
The actual negative value we used isn't taken into consideration, we would get the same result if we used <code>-150</code>.
If we set the <code>limit</code> to <code>0</code>, the String would again be split as many times as possible, but the resulting array wouldn't contain the trailing empty spaces:
<pre><code class="hljs">String myString = &quot;there,,are,more,than,three,commas,,,&quot;;

// Equivalent to calling the split() method with only the regex parameter
String [] splitStrings = myString.split(&quot;,&quot;, 0);

for(String string : splitStrings){
 System.out.println(String.format(&quot; \&quot; %s \&quot;&quot;, string));
}
</code></pre>
This would give us:
<pre><code class="hljs">&quot;there&quot;
&quot;&quot;
&quot;are&quot;
&quot;more&quot;
&quot;than&quot;
&quot;three&quot;
&quot;commas&quot;
</code></pre>
<h2 id="noteonspecialcharacters">Note on Special Characters</h2>
As we mentioned earlier, the <code>regex</code> parameter passed as the delimiter in the <code>split()</code> method is a regular expression. We have to make sure to escape special characters if we want to use their literal value as a delimiter. For example, the <code>*</code> character means &quot;one or more instances of the following character(s)&quot;.
There are 12 such characters in regex. These are: <code>\</code>, <code>^</code>, <code>$</code>, <code>.</code>, <code>|</code>, <code>?</code>, <code>*</code>, <code>+</code>, <code>(</code>, <code>)</code>, <code>[</code>, <code>{</code>. You can see their meaning in regex <a rel='nofollow noopener' target="_blank" href="https://www.regular-expressions.info/characters.html#:~:text=In%20the%20regex%20flavors%20discussed,%2C%20the%20closing%20parenthesis%20)%2C%20the">here</a>.
If we want to split a <code>String</code> at one of these characters, special care has to be taken to escape these characters in the method parameters. One way we can use this is to use a backslash <code>\</code>. For example:
<pre><code class="hljs">string.split(&quot;\\|&quot;);
</code></pre>
Splits the <code>string</code> variable at the <code>|</code> character. We use two backlashes here since we need to first escape the Java-meaning of the backlash, so the backslash can be applied to the <code>|</code> character.
Instead of this, we can use a regex character set This refers to putting the special characters to be escaped inside square brackets. This way, the special characters are treated as normal characters. For example, we could use a <code>|</code> as a delimiter by saying:
<pre><code class="hljs">string.split(&quot;[|]&quot;);
</code></pre>
Yet another way to escape special characters is to use <code>Pattern.quote()</code>:
<pre><code class="hljs">string.split(Pattern.quote(&quot;|&quot;));
</code></pre>
<h2 id="conclusion">Conclusion</h2>
The <code>split()</code> method of the Java <code>String</code> class is a very useful and often used tool. Most data, especially that obtained from reading files would require some amount of preprocessing, such as splitting the string, to obtain meaningful information from it.
In this article, we've gone over how to split strings in Java.

Guest Contributor

In this article, we'll take a look at how we can split a string in Java. We will also explore different examples and common issues with using the split() method.

How to Split a String in Java

<h2 id="introduction">Introduction</h2>
Seaborn is one of the most widely used data visualization libraries in Python, as an extension to Matplotlib. It offers a simple, intuitive, yet highly customizable API for data visualization.
In this tutorial, we'll take a look at how to plot a scatter plot in Seaborn. We'll cover simple scatter plots, multiple scatter plots with FacetGrid as well as 3D scatter plots.
<h2 id="importdata">Import Data</h2>
We'll use the <a rel="nofollow noopener" target="_blank" href="https://www.kaggle.com/unsdsn/world-happiness">World Happiness</a> dataset, and compare the Happiness Score against varying features to see what influences perceived happiness in the world:
<pre><code class="hljs">import pandas as pd

df = pd.read_csv(&#x27;worldHappiness2016.csv&#x27;)
</code></pre>
<h2 id="plotascatterplotinseaborn">Plot a Scatter Plot in Seaborn</h2>
Now, with the dataset loaded, let's import PyPlot, which we'll use to show the graph, as well as Seaborn. We'll plot the Happiness Score against the country's Economy (GDP per Capita):
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd

df = pd.read_csv(&#x27;worldHappiness2016.csv&#x27;)

sns.scatterplot(data = df, x = &quot;Economy (GDP per Capita)&quot;, y = &quot;Happiness Score&quot;)

plt.show()
</code></pre>
Seaborn makes it really easy to plot basic graphs like scatter plots. We don't need to fiddle with the <code>Figure</code> object, <code>Axes</code> instances or set anything up, although, we can if we want to. Here, we've supplied the <code>df</code> as the <code>data</code> argument, and provided the features we want to visualize as the <code>x</code> and <code>y</code> arguments.
These have to match the data present in the dataset and the default labels will be their names. We'll customize this in a later section.
Now, if we run this code, we're greeted with:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-scatter-plot-tutorial-and-examples-1.png" alt="seaborn simple scatter plot tutorial">
Here, there's a strong positive correlation between the economy (GDP per capita) and the perceived happiness of the inhabitants of a country/region.
<h2 id="plottingmultiplescatterplotsinseabornwithfacetgrid">Plotting Multiple Scatter Plots in Seaborn with FacetGrid</h2>
If you'd like to compare more than one variable against another, such as - the average life expectancy, as well as the happiness score against the economy, or any variation of this, there's no need to create a 3D plot for this.
While 2D plots that visualize correlations between more than two variables exist, some of them aren't fully beginner friendly.
Seaborn allows us to construct a <code>FacetGrid</code> object, which we can use to facet the data and construct multiple, related plots, one next to the other.
Let's take a look at how to do that:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns

df = pd.read_csv(&#x27;worldHappiness2016.csv&#x27;)

grid = sns.FacetGrid(df, col = &quot;Region&quot;, hue = &quot;Region&quot;, col_wrap=5)
grid.map(sns.scatterplot, &quot;Economy (GDP per Capita)&quot;, &quot;Health (Life Expectancy)&quot;)

grid.add_legend()

plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-scatter-plot-tutorial-and-examples-2.png" alt="seaborn facetgrid multiple scatter plots tutorial">
Here, we've created a <code>FacetGrid</code>, passing our data (<code>df</code>) to it. By specifying the <code>col</code> argument as <code>&quot;Region&quot;</code>, we've told Seaborn that we'd like to facet the data into regions and plot a scatter plot for each region in the dataset.
We've also assigned the <code>hue</code> to depend on the region, so each region has a different color. Finally, we've set the <code>col_wrap</code> argument to <code>5</code> so that the entire figure isn't too wide - it breaks on every 5 columns into a new row.
To this <code>grid</code> object, we <code>map()</code> our arguments. Specifically, we specified a <code>sns.scatterplot</code> as the type of plot we'd like, as well as the <code>x</code> and <code>y</code> variables we want to plot in these scatter plots.
This results in 10 different scatter plots, each with the related <code>x</code> and <code>y</code> data, separated by region.
We've also added a legend in the end, to help identify the colors.
<h2 id="plottinga3dscatterplotinseaborn">Plotting a 3D Scatter Plot in Seaborn</h2>
Seaborn doesn't come with any built-in 3D functionality, unfortunately. It's an extension of Matplotlib and relies on it for the heavy lifting in 3D. Though, we can style the 3D Matplotlib plot, using Seaborn.
Let's set the style using Seaborn, and visualize a 3D scatter plot between happiness, economy and health:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
from mpl_toolkits.mplot3d import Axes3D

df = pd.read_csv(&#x27;2016.csv&#x27;)
sns.set(style = &quot;darkgrid&quot;)

fig = plt.figure()
ax = fig.add_subplot(111, projection = &#x27;3d&#x27;)

x = df[&#x27;Happiness Score&#x27;]
y = df[&#x27;Economy (GDP per Capita)&#x27;]
z = df[&#x27;Health (Life Expectancy)&#x27;]

ax.set_xlabel(&quot;Happiness&quot;)
ax.set_ylabel(&quot;Economy&quot;)
ax.set_zlabel(&quot;Health&quot;)

ax.scatter(x, y, z)

plt.show()
</code></pre>
Running this code results in an interactive 3D visualization that we can pan and inspect in three-dimensional space, styled as a Seaborn plot:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-scatter-plot-tutorial-and-examples-3.gif" alt="seaborn 3d scatter plot">
<h2 id="customizingscatterplotsinseaborn">Customizing Scatter Plots in Seaborn</h2>
Using Seaborn, it's easy to customize various elements of the plots you make. For example, you can set the <code>hue</code> and <code>size</code> of each marker on a scatter plot.
Let's change some of the options and see how the plot looks like when altered:
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd

df = pd.read_csv(&#x27;2016.csv&#x27;)

sns.scatterplot(data = df, x = &quot;Economy (GDP per Capita)&quot;, y = &quot;Happiness Score&quot;, hue = &quot;Region&quot;, size = &quot;Freedom&quot;)

plt.show()
</code></pre>
Here, we've set the <code>hue</code> to <code>Region</code> which means that data from different regions will have different colors. Also, we've set the <code>size</code> to be proportional to the Freedom feature. The higher the freedom factor is, the larger the dots are:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-scatter-plot-tutorial-and-examples-4.png" alt="seaborn customizing scatter plot">
Or you can set a fixed size for all markers, as well as a color:
<pre><code class="hljs">sns.scatterplot(data = df, x = &quot;Economy (GDP per Capita)&quot;, y = &quot;Happiness Score&quot;, hue = &quot;red&quot;, size = 5)
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to plot a scatter plot using Seaborn and Python.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Become dangerous with Data Visualization
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with theses libraries - from simple plots to animated 3D plots with interactive buttons.
<blockquote>
It serves as an in-depth, guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
</blockquote>
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, cover core plotting libraries like Matplotlib and Seaborn, and show you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.
</blockquote>

In this tutorial, we'll go over how to plot a Seaborn scatter plot in Python. We'll go over simple plotting examples, as well as multi-faceted plotting of multiple plots and 3D plots using Seaborn and Matplotlib.