<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.

Seaborn Scatter Plot - Tutorial and Examples

<h2 id="introduction">Introduction</h2>
It's common to see <code>if __name__ == &quot;__main__&quot;</code> in Python scripts we find online, or one of the many we write ourselves.
Why do we use that if-statement when running our Python programs? In this article, we explain the mechanics behind its usage, the advantages, and where it can be used.
<h2 id="the__name__attributeandthe__main__scope">The __name__ Attribute and the __main__ Scope</h2>
The <code>__name__</code> attribute comes by default as one of the names in the current local scope. The Python interpreter automatically adds this value when we are running a Python script or importing our code as a module.
Try out the following command on your Python interpreter. You may find out that <code>__name__</code> belongs to the list of attributes in <code>dir()</code>:
<pre><code class="hljs">dir()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/what-does-if-name-equals-main-do-in-python-1.gif" alt="dir() output">
The <code>__name__</code> in Python is a special variable that defines the name of the class or the current module or the script from which it gets invoked.
Create a new folder called <code>name_scripts</code> so we can write a few scripts to understand how this all works. In that folder create a new file, <code>script1.py</code> with the following code:
<pre><code class="hljs">print(f&#x27;The __name__ from script1 is &quot;{__name__}&quot;&#x27;)
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/what-does-if-name-equals-main-do-in-python-2.gif" alt="script1.py output">
That's a curveball! We'd expect that the name would be <code>script1</code>, as our file. What does the output <code>__main__</code> mean?
By default, when a script is executed, the interpreter reads the script and assigns the string <code>__main__</code> to the <code>__name__</code> keyword.
It gets even more interesting when the above script gets imported to another script. Consider a Python file named <code>script2.py</code> with the following code:
<pre><code class="hljs">import script1 # The print statement gets executed upon import

print(f&#x27;The __name__ from script2 is &quot;{__name__}&quot;&#x27;)
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/what-does-if-name-equals-main-do-in-python-3.gif" alt="script2.py output">
As you can see, when the script is executed the output is given as <code>script1</code> denoting the name of the script. The final print statement is in the scope of <code>script2</code> and when it gets executed, the output gets printed as: <code>__main__</code>.
Now that we understand how Python uses the <code>__name__</code> scope and when it gives it a value of &quot;__main__&quot;, let's look at why we check for its value before executing code.
<h2 id="if__name____main__inaction">if __name__ == &quot;__main__&quot; in Action</h2>
We use the if-statement to run blocks of code only if our program is the main program executed. This allows our program to be executable by itself, but friendly to other Python modules who may want to import some functionality without having to run the code.
Consider the following Python programs:
a) <code>script3.py</code> contains a function called <code>add()</code> which gets invoked only from the main context.
<pre><code class="hljs">def add(a, b):
 return a+b


if __name__ == &quot;__main__&quot;:
 print(add(2, 3))
</code></pre>
Here's the output when <code>script3.py</code> gets invoked:
<img src="https://stackabuse.s3.amazonaws.com/media/what-does-if-name-equals-main-do-in-python-4.gif" alt="script3.py output">
As the script was executed directly, the <code>__name__</code> keyword is assigned to <code>__main__</code>, and the block of code under the <code>if __name__ == &quot;__main__&quot;</code> condition is executed.
b) Here's what happens when this snippet is imported from <code>script4.py</code>:
<pre><code class="hljs">import script3

print(f&quot;{script3.__name__}&quot;)
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/what-does-if-name-equals-main-do-in-python-5.gif" alt="script4.py output">
The block under <code>if __name__ == &quot;__main__&quot;</code> from <code>script3.py</code> did not execute, as expected. This happened because the <code>__name__</code> keyword is now assigned with the name of the script: <code>script3</code>. This can be verified by the print statement given which prints the assigned value for the <code>__name__</code> keyword.
<h2 id="howdoes__name____main__helpindevelopment">How Does __name__ == &quot;__main__&quot; Help in Development?</h2>
Here are some use cases for using that if-statement when creating your script
<ul>
<li>Testing is a good practice which helps not only catch bugs but ensure your code behaves as required. Test files have to import a function or object to them. In these cases, we typically don't want the script being run as the main module.</li>
<li>You're creating a library but would like to include a demo or other special run-time cases for users. By using this if-statement, the Python modules that use your code as a library are unaffected.</li>
</ul>
<h2 id="creatinga__main__pyfileformodules">Creating a __main__.py File for Modules</h2>
The point of having the <code>if __name__ == &quot;__main__&quot;</code> block is to get the piece of code under the condition to get executed when the script is in the <code>__main__</code> scope. While creating packages in Python, however, it's better if the code to be executed under the <code>__main__</code> context is written in a separate file.
Let's consider the following example - a package for performing calculations. The file tree structure for such a scenario can be visualized as:
<pre><code class="hljs">calc # --&gt; Root directory
├── __main__.py
├── script1.py
├── script2.py
├── script3.py
├── script4.py
└── src # --&gt; Sub-directory
 ├── add.py
 └── sub.py
</code></pre>
The tree structure contains <code>calc</code> as the root directory and a sub-directory known as <code>src</code>. The <code>__main__.py</code> under the <code>calc</code> directory contains the following content:
<pre><code class="hljs">from src.add import add
from src.sub import sub

a, b = input(&quot;Enter two numbers separated by commas: &quot;).split(&#x27;,&#x27;)
a, b = int(a), int(b)

print(f&quot;The sum is: {add(a, b)}&quot;)
print(f&quot;The difference is: {sub(a, b)}&quot;)
</code></pre>
The <code>add.py</code> contains:
<pre><code class="hljs">def add(a, b):
 return a+b
</code></pre>
And <code>sub.py</code> contains:
<pre><code class="hljs">def sub(a, b):
 return a-b
</code></pre>
From right outside the <code>calc</code> directory, the script can be executed and the logic inside the <code>__main__.py</code> gets executed by invoking:
<pre><code class="hljs">python3 calc
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/what-does-if-name-equals-main-do-in-python-6.gif" alt="script1.py output">
This structure also gives a cleaner look to the workspace location, the way how the directories are organized, and the entry point is defined inside a separate file called <code>__main__.py</code>.
<h2 id="conclusion">Conclusion</h2>
The <code>__name__ == &quot;__main__&quot;</code> runs blocks of code only when our Python script is being executed directly from a user. This is powerful as it allows our code to have different behavior when it's being executed as a program instead of being imported as a module.
When writing large modules, we can opt for the more structured approach of having a <code>__main__.py</code> file to run a module. For a stand-alone script, including the <code>if __name__ == &quot;__main__&quot;</code> is a simpler method to separate the API from the program.

Marcus Sanatan

Sathiya Sarathi Gunasekaran

if __name__ == "__main__" is used to control the behavior of our Python code when it's executed directly or imported as a module. This tutorial explains how.

What Does "if __name__ == __main__:"" Do in Python?

What Does if __name__ == "__main__": Do in Python?

<h2 id="introduction">Introduction</h2>
State-of-the-art technologies in NLP allow us to analyze natural languages on different layers: from simple <a target="_blank" href="/simple-nlp-in-python-with-textblob-tokenization/">segmentation</a> of textual information to more sophisticated methods of sentiment categorizations.
However, it does not inevitably mean that you should be highly advanced in programming to implement high-level tasks such as sentiment analysis in Python.
<h2 id="sentimentanalysis">Sentiment Analysis</h2>
The algorithms of sentiment analysis mostly focus on defining opinions, attitudes, and even emoticons in a corpus of texts. The range of established sentiments significantly varies from one method to another. While a standard analyzer defines up to three basic polar emotions (positive, negative, neutral), the limit of more advanced models is broader.
Consequently, they can look beyond polarity and determine six &quot;universal&quot; emotions (e.g. anger, disgust, fear, happiness, sadness, and surprise):
<img src="https://stackabuse.s3.amazonaws.com/media/sentiment-analysis-in-python-with-textblob-1.jpg" alt="Scale of Emotions"> 
 Source: <a rel="nofollow noopener" target="_blank" href="https://mentalhealth.ie/blog/2019/1/7/how-to-listen-to-your-emotions">Spectrum Mental Health</a>
Moreover, depending on the task you're working on, it's also possible to collect extra information from the context such as the author or a topic that in further analysis can prevent a more complex issue than a common polarity classification - namely, subjectivity/objectivity identification.
For example, this sentence from Business insider: &quot;In March, Elon Musk described concern over the coronavirus outbreak as &quot;panic&quot; and &quot;dumb,&quot; and he's since tweeted incorrect information, such as his theory that children are &quot;essentially immune&quot; to the virus.&quot; expresses subjectivity through a personal opinion of E. Musk, as well as the author of the text.
<h2 id="sentimentanalysisinpythonwithtextblob">Sentiment Analysis in Python with TextBlob</h2>
The approach that the TextBlob package applies to sentiment analysis differs in that it’s rule-based and therefore requires a predefined set of categorized words. These words can, for example, be uploaded from the NLTK database. Moreover, sentiments are defined based on semantic relations and the frequency of each word in an input sentence that allows getting a more precise output as a result.
Once the first step is accomplished and a Python model is fed by the necessary input data, a user can obtain the sentiment scores in the form of polarity and subjectivity that were discussed in the previous section. We can see how this process works in this paper by <a target="_blank" rel="nofollow noopener" href="https://www.cs.rit.edu/usr/local/pub/GraduateProjects/2165/fjk9481/Report.pdf">Forum Kapadia</a>:
<img src="https://stackabuse.s3.amazonaws.com/media/sentiment-analysis-in-python-with-textblob-2.jpg" alt="TextBlob stream">
TextBlob’s output for a polarity task is a float within the range <code>[-1.0, 1.0]</code> where <code>-1.0</code> is a negative polarity and <code>1.0</code> is positive. This score can also be equal to <code>0</code>, which stands for a neutral evaluation of a statement as it doesn’t contain any words from the training set.
Whereas, a subjectivity/objectivity identification task reports a float within the range <code>[0.0, 1.0]</code> where <code>0.0</code> is a very objective sentence and <code>1.0</code> is very subjective.
There are various examples of Python interaction with TextBlob sentiment analyzer: starting from a model based on different <a target="_blank" rel="nofollow noopener" href="https://www.kaggle.com/">Kaggle</a> datasets (e.g. movie reviews) to calculating tweet sentiments through the <a target="_blank" href="https://stackabuse.com/accessing-the-twitter-api-with-python/">Twitter API</a>.
But, let’s look at a simple analyzer that we could apply to a particular sentence or a short text. We first start with importing the TextBlob library:
<pre><code class="hljs"># Importing TextBlob
from textblob import TextBlob
</code></pre>
Once imported, we'll load in a sentence for analysis and instantiate a <code>TextBlob</code> object, as well as assigning the <code>sentiment</code> property to our own <code>analysis</code>:
<pre><code class="hljs"># Preparing an input sentence
sentence = &#x27;&#x27;&#x27;The platform provides universal access to the world&#x27;s best education, partnering with top universities and organizations to offer courses online.&#x27;&#x27;&#x27;

# Creating a textblob object and assigning the sentiment property
analysis = TextBlob(sentence).sentiment
print(analysis)
</code></pre>
The <code>sentiment</code> property is a <code>namedtuple</code> of the form <code>Sentiment(polarity, subjectivity)</code>.
Where the expected output of the analysis is:
<pre><code class="hljs">Sentiment(polarity=0.5, subjectivity=0.26666666666666666)
</code></pre>
Moreover, it’s also possible to go for polarity or subjectivity results separately by simply running the following:
<pre><code class="hljs">from textblob import TextBlob

# Preparing an input sentence
sentence = &#x27;&#x27;&#x27;The platform provides universal access to the world&#x27;s best education, partnering with top universities and organizations to offer courses online.&#x27;&#x27;&#x27;

analysisPol = TextBlob(sentence).polarity
analysisSub = TextBlob(sentence).subjectivity

print(analysisPol)
print(analysisSub)
</code></pre>
Which would give us the output:
<pre><code class="hljs">0.5
0.26666666666666666
</code></pre>
One of the great things about TextBlob is that it allows the user to choose an algorithm for implementation of the high-level NLP tasks:
<ul>
<li><code>PatternAnalyzer</code> - a default classifier that is built on the pattern library</li>
<li><code>NaiveBayesAnalyzer</code> - an NLTK model trained on a movie reviews corpus</li>
</ul>
To change the default settings, we'll simply specify a <code>NaiveBayes</code> analyzer in the code. Let’s run sentiment analysis on tweets directly from <a target="_blank" rel="nofollow noopener" href="https://twitter.com/">Twitter</a>:
<pre><code class="hljs">from textblob import TextBlob
# For parsing tweets
import tweepy 

# Importing the NaiveBayesAnalyzer classifier from NLTK
from textblob.sentiments import NaiveBayesAnalyzer
</code></pre>
After that, we need to establish a connection with the Twitter API via API keys (that you can get through a <a target="_blank" rel="nofollow noopener" href="https://developer.twitter.com/en">developer account</a>):
<pre><code class="hljs"># Uploading api keys and tokens
api_key = &#x27;XXXXXXXXXXXXXXX&#x27;
api_secret = &#x27;XXXXXXXXXXXXXXX&#x27;
access_token = &#x27;XXXXXXXXXXXXXXX&#x27;
access_secret = &#x27;XXXXXXXXXXXXXXX&#x27;

# Establishing the connection
twitter = tweepy.OAuthHandler(api_key, api_secret)
api = tweepy.API(twitter)
</code></pre>
Now, we can perform the analysis of tweets on any topic. A searched word (e.g. lockdown) can be both one word or more. Moreover, this task can be time-consuming due to a tremendous amount of tweets. It's recommended to limit the output:
<pre><code class="hljs"># This command will call back 5 tweets within a “lockdown” topic
corpus_tweets = api.search(&quot;lockdown&quot;, count=5) 
for tweet in corpus_tweets:
 print(tweet.text)
</code></pre>
The output of this last piece of code will bring back five tweets that mention your searched word in the following form:
<pre><code class="hljs">RT@DhwaniPandya: How Asia&#x27;s densest slum contained the virus and the economic catastrophe that stares at the hardworking slum population...
</code></pre>
The last step in this example is switching the default model to the NLTK analyzer that returns its results as a <code>namedtuple</code> of the form: <code>Sentiment(classification, p_pos, p_neg)</code>:
<pre><code class="hljs"># Applying the NaiveBayesAnalyzer
blob_object = TextBlob(tweet.text, analyzer=NaiveBayesAnalyzer())
# Running sentiment analysis
analysis = blob_object.sentiment
print(analysis)
</code></pre>
Finally, our Python model will get us the following sentiment evaluation:
<pre><code class="hljs">Sentiment(classification=&#x27;pos&#x27;, p_pos=0.5057908299783777, p_neg=0.49420917002162196)
</code></pre>
Here, it's classified it as a positive sentiment, with the <code>p_pos</code> and <code>p_neg</code> values being ~<code>0.5</code> each.
<h2 id="conclusion">Conclusion</h2>
In this article, we've covered what Sentiment Analysis is, after which we've used the TextBlob library to perform Sentiment Analysis on imported sentences as well as tweets.

Natalia Kuzminykh

In this article, we will take a look at how we can use the TextBlob library for sentiment analysis. We will also go through an example of how to analyze tweet sentiments.

Sentiment Analysis in Python With TextBlob

<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 Strings in Python.
<h2 id="slicingastringinpython">Slicing a String in Python</h2>
There are a couple of ways to slice a string, most common of which is by using the <code>:</code> operator with the following syntax:
<pre><code class="hljs">string[start:end]
string[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.
Let's go ahead and slice a string:
<pre><code class="hljs">string = &#x27;No. I am your father.&#x27;
print(string[4:20])
</code></pre>
This will omit the first four characters in the string:
<pre><code class="hljs">I am your father
</code></pre>
<h3 id="findingtheprefixandsuffixoflengthnwithslicenotation">Finding the Prefix and Suffix of Length n with Slice Notation</h3>
To find the prefix or suffix of length <code>n</code> of a string, we'll use the same approach that can be used to find the tail or head of a list. We'll slice from the start to <code>n</code> and from <code>-n</code> to the end of the string.
In this case, <code>-n</code> will start counting from the end of the string, backwards, giving us a suffix:
<pre><code class="hljs">n = 4
string = &#x27;Now, young Skywalker, you will die.&#x27;

# Prefix of length n
print(string[:n])
# Suffix of length n
print(string[-n:])
</code></pre>
This results in:
<pre><code class="hljs">Now,
die.
</code></pre>
<h3 id="reverseastringusingslicenotation">Reverse a String using Slice Notation</h3>
To reverse a string, we can set the <code>step</code> of the slice notation to <code>-1</code>. This makes the step go backwards, including each element it steps on, resulting in the string being printed back in reverse:
<pre><code class="hljs">string = &#x27;I’ll never turn to the dark side. You’ve failed, your highness. I am a Jedi, like my father before me.&#x27;
print(string[::-1])
</code></pre>
This code would result in:
<pre><code class="hljs">.em erofeb rehtaf ym ekil ,ideJ a ma I .ssenhgih ruoy ,deliaf ev’uoY .edis krad eht ot nrut reven ll’I
</code></pre>
<h3 id="findingeverynthcharacterinastring">Finding Every n-th Character in a String</h3>
Extracting every n-th character comes down to setting the step parameter to <code>n</code>. If you want every second character, you'd step over every second character as well:
<pre><code class="hljs">n = 3
string = &#x27;There’s always a bigger fish.&#x27;
print(string[::n])
</code></pre>
This code will print out every third letter:
<pre><code class="hljs">Trslyaiefh
</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 Strings in Python.

Kristina Popovic

In this tutorial, we'll go over examples of how to slice a string in Python. We'll also find a prefix and suffix, reverse a string and find every n-th character in a string.

Python: Slice Notation on String

<h2 id="introduction">Introduction</h2>
Matplotlib is one of the most widely used data visualization libraries in Python. From simple to complex visualizations, it's the go-to library for most.
In this guide, we'll take a look at how to plot a Scatter Plot with Matplotlib.
<blockquote>
Scatter Plots explore the relationship between two numerical variables (features) of a dataset.
</blockquote>
<h2 id="importdata">Import Data</h2>
We'll be using the <a rel="noopener nofollow" target="_blank" href="https://www.kaggle.com/prevek18/ames-housing-dataset">Ames Housing</a> dataset and visualizing correlations between features from it.
Let's import Pandas and load in the dataset:
<pre><code class="hljs">import pandas as pd

df = pd.read_csv(&#x27;AmesHousing.csv&#x27;)
</code></pre>
<h2 id="plotascatterplotinmatplotlib">Plot a Scatter Plot in Matplotlib</h2>
Now, with the dataset loaded, let's import Matplotlib, decide on the features we want to visualize, and construct a scatter plot:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd

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

fig, ax = plt.subplots(figsize=(10, 6))
ax.scatter(x = df[&#x27;Gr Liv Area&#x27;], y = df[&#x27;SalePrice&#x27;])
plt.xlabel(&quot;Living Area Above Ground&quot;)
plt.ylabel(&quot;House Price&quot;)

plt.show()
</code></pre>
Here, we've created a plot, using the PyPlot instance, and set the figure size. Using the returned <code>Axes</code> object, which is returned from the <code>subplots()</code> function, we've called the <code>scatter()</code> function.
We need to supply the <code>x</code> and <code>y</code> arguments as the features we'd like to use to populate the plot. Running this code results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-scatterplot-tutorial-and-examples-1.png" alt="matplotlib simple scatter plot tutorial">
We've also set the x and y labels to indicate what the variables represent. There's a clear positive correlation between these two variables. The more area there is above ground-level, the higher the price of the house was.
There are a few outliers, but the vast majority follows this hypothesis.
<h2 id="plottingmultiplescatterplotsinmatplotlib">Plotting Multiple Scatter Plots in Matplotlib</h2>
If you'd like to compare more than one variable against another, such as - check the correlation between the overall quality of the house against the sale price, as well as the area above ground level - there's no need to make 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.
An easy way to do this is to plot two plots - in one, we'll plot the area above ground level against the sale price, in the other, we'll plot the overall quality against the sale price.
Let's take a look at how to do that:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd

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

fig, ax = plt.subplots(2, figsize=(10, 6))
ax[0].scatter(x = df[&#x27;Gr Liv Area&#x27;], y = df[&#x27;SalePrice&#x27;])
ax[0].set_xlabel(&quot;Living Area Above Ground&quot;)
ax[0].set_ylabel(&quot;House Price&quot;)

ax[1].scatter(x = df[&#x27;Overall Qual&#x27;], y = df[&#x27;SalePrice&#x27;])
ax[1].set_xlabel(&quot;Overall Quality&quot;)
ax[1].set_ylabel(&quot;House Price&quot;)

plt.show()
</code></pre>
Here, we've called <code>plt.subplots()</code>, passing <code>2</code> to indicate that we'd like to instantiate two subplots in the figure.
We can access these via the <code>Axes</code> instance - <code>ax</code>. <code>ax[0]</code> refers to the first subplot's axes, while <code>ax[1]</code> refers to the second subplot's axes.
Here, we've called the <code>scatter()</code> function on each of them, providing them with labels. Running this code results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-scatterplot-tutorial-and-examples-2.png" alt="matplotlib multiple scatter plots in subplots">
<h2 id="plottinga3dscatterplotinmatplotlib">Plotting a 3D Scatter Plot in Matplotlib</h2>
If you don't want to visualize this in two separate subplots, you can plot the correlation between these variables in 3D. Matplotlib has built-in 3D plotting functionality, so doing this is a breeze.
First, we'll need to import the <code>Axes3D</code> class from <code>mpl_toolkits.mplot3d</code>. This special type of <code>Axes</code> is needed for 3D visualizations. With it, we can pass in another argument - <code>z</code>, which is the third feature we'd like to visualize.
Let's go ahead and import the <code>Axes3D</code> object and plot a scatter plot against the previous three features:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd
from mpl_toolkits.mplot3d import Axes3D

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

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

x = df[&#x27;SalePrice&#x27;]
y = df[&#x27;Gr Liv Area&#x27;]
z = df[&#x27;Overall Qual&#x27;]

ax.scatter(x, y, z)
ax.set_xlabel(&quot;Sale price&quot;)
ax.set_ylabel(&quot;Living area above ground level&quot;)
ax.set_zlabel(&quot;Overall quality&quot;)

plt.show()
</code></pre>
Running this code results in an interactive 3D visualization that we can pan and inspect in three-dimensional space:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-scatterplot-tutorial-and-examples-3.png" alt="matplotlib 3d scatter plot"> 
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-scatterplot-tutorial-and-examples-4.png" alt="matplotlib 3d scatter plot">
<h2 id="customizingscatterplotinmatplotlib">Customizing Scatter Plot in Matplotlib</h2>
You can change how the plot looks like by supplying the <code>scatter()</code> function with additional arguments, such as <code>color</code>, <code>alpha</code>, etc:
<pre><code class="hljs">ax.scatter(x = df[&#x27;Gr Liv Area&#x27;], y = df[&#x27;SalePrice&#x27;], color = &quot;blue&quot;, edgecolors = &quot;white&quot;, linewidths = 0.1, alpha = 0.7)
</code></pre>
Running this code would result in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-scatterplot-tutorial-and-examples-5.png" alt="matplotlib customize scatter plot">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to plot a scatter plot using Matplotlib 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 scatter plot in Python using Matplotlib. We'll cover scatter plots, multiple scatter plots on subplots and 3D scatter plots.