<h2 id="introduction">Introduction</h2>
Pandas is an immensely popular data manipulation framework for Python. In a lot of cases, you might want to iterate over data - either to print it out, or perform some operations on it.
In this tutorial, we'll take a look at how to iterate over rows in a Pandas <code>DataFrame</code>.
If you're new to Pandas, you can read our <a href="/beginners-tutorial-on-the-pandas-python-library/">beginner's tutorial</a>. Once you're familiar, let's look at the three main ways to iterate over DataFrame:
<ul>
<li><code>items()</code></li>
<li><code>iterrows()</code></li>
<li><code>itertuples()</code></li>
</ul>
<h2 id="iteratingdataframeswithitems">Iterating DataFrames with items()</h2>
Let's set up a <code>DataFrame</code> with some data of fictional people:
<pre><code class="hljs">import pandas as pd

df = pd.DataFrame({
 &#x27;first_name&#x27;: [&#x27;John&#x27;, &#x27;Jane&#x27;, &#x27;Marry&#x27;, &#x27;Victoria&#x27;, &#x27;Gabriel&#x27;, &#x27;Layla&#x27;],
 &#x27;last_name&#x27;: [&#x27;Smith&#x27;, &#x27;Doe&#x27;, &#x27;Jackson&#x27;, &#x27;Smith&#x27;, &#x27;Brown&#x27;, &#x27;Martinez&#x27;],
 &#x27;age&#x27;: [34, 29, 37, 52, 26, 32]},
 index=[&#x27;id001&#x27;, &#x27;id002&#x27;, &#x27;id003&#x27;, &#x27;id004&#x27;, &#x27;id005&#x27;, &#x27;id006&#x27;])
</code></pre>
Note that we are using id's as our <code>DataFrame</code>'s index. Let's take a look at how the <code>DataFrame</code> looks like:
<pre><code class="hljs">print(df.to_string())
</code></pre>
<pre><code class="hljs"> first_name last_name age
id001 John Smith 34
id002 Jane Doe 29
id003 Marry Jackson 37
id004 Victoria Smith 52
id005 Gabriel Brown 26
id006 Layla Martinez 32
</code></pre>
Now, to iterate over this <code>DataFrame</code>, we'll use the <code>items()</code> function:
<pre><code class="hljs">df.items()
</code></pre>
This returns a <a href="/python-generators/">generator</a>:
<pre><code class="hljs">&lt;generator object DataFrame.items at 0x7f3c064c1900&gt;
</code></pre>
We can use this to generate pairs of <code>col_name</code> and <code>data</code>. These pairs will contain a column name and every row of data for that column. Let's loop through column names and their data:
<pre><code class="hljs">for col_name, data in df.items():
 print(&quot;col_name:&quot;,col_name, &quot;\ndata:&quot;,data)
</code></pre>
This results in:
<pre><code class="hljs">col_name: first_name
data: 
id001 John
id002 Jane
id003 Marry
id004 Victoria
id005 Gabriel
id006 Layla
Name: first_name, dtype: object
col_name: last_name
data: 
id001 Smith
id002 Doe
id003 Jackson
id004 Smith
id005 Brown
id006 Martinez
Name: last_name, dtype: object
col_name: age
data: 
id001 34
id002 29
id003 37
id004 52
id005 26
id006 32
Name: age, dtype: int64
</code></pre>
We've successfully iterated over all rows in each column. Notice that the index column stays the same over the iteration, as this is the associated index for the values. If you don't define an index, then Pandas will enumerate the index column accordingly.
We can also print a particular row with passing index number to the <code>data</code> as we do with Python lists:
<pre><code class="hljs">for col_name, data in df.items():
 print(&quot;col_name:&quot;,col_name, &quot;\ndata:&quot;,data[1])
</code></pre>
Note that list index are zero-indexed, so <code>data[1]</code> would refer to the second row. You will see this output:
<pre><code class="hljs">col_name: first_name 
data: Jane
col_name: last_name 
data: Doe
col_name: age 
data: 29
</code></pre>
We can also pass the index value to <code>data</code>.
<pre><code class="hljs">for col_name, data in df.items():
 print(&quot;col_name:&quot;,col_name, &quot;\ndata:&quot;,data[&#x27;id002&#x27;])
</code></pre>
The output would be the same as before:
<pre><code class="hljs">col_name: first_name
data: Jane
col_name: last_name
data: Doe
col_name: age
data: 29
</code></pre>
<h2 id="iteratingdataframeswithiterrows">Iterating DataFrames with iterrows()</h2>
While <code>df.items()</code> iterates over the rows in column-wise, doing a cycle for each column, we can use <code>iterrows()</code> to get the entire row-data of an index.
Let's try iterating over the rows with <code>iterrows()</code>:
<pre><code class="hljs">for i, row in df.iterrows():
 print(f&quot;Index: {i}&quot;)
 print(f&quot;{row}\n&quot;)
</code></pre>
In the for loop, <code>i</code> represents the index column (our DataFrame has indices from <code>id001</code> to <code>id006</code>) and <code>row</code> contains the data for that index in all columns. Our output would look like this:
<pre><code class="hljs">Index: id001
first_name John
last_name Smith
age 34
Name: id001, dtype: object

Index: id002
first_name Jane
last_name Doe
age 29
Name: id002, dtype: object

Index: id003
first_name Marry
last_name Jackson
age 37
Name: id003, dtype: object

...
</code></pre>
Likewise, we can iterate over the rows in a certain column. Simply passing the index number or the column name to the <code>row</code>. For example, we can selectively print the first column of the row like this:
<pre><code class="hljs">for i, row in df.iterrows():
 print(f&quot;Index: {i}&quot;)
 print(f&quot;{row[&#x27;0&#x27;]}&quot;)
</code></pre>
Or:
<pre><code class="hljs">for i, row in df.iterrows():
 print(f&quot;Index: {i}&quot;)
 print(f&quot;{row[&#x27;first_name&#x27;]}&quot;)
</code></pre>
They both produce this output:
<pre><code class="hljs">Index: id001
John
Index: id002
Jane
Index: id003
Marry
Index: id004
Victoria
Index: id005
Gabriel
Index: id006
Layla
</code></pre>
<h2 id="iteratingdataframeswithitertuples">Iterating DataFrames with itertuples()</h2>
The <code>itertuples()</code> function will also return a generator, which generates row values in tuples. Let's try this out:
<pre><code class="hljs">for row in df.itertuples():
 print(row)
</code></pre>
You'll see this in your Python shell:
<pre><code class="hljs">Pandas(Index=&#x27;id001&#x27;, first_name=&#x27;John&#x27;, last_name=&#x27;Smith&#x27;, age=34)
Pandas(Index=&#x27;id002&#x27;, first_name=&#x27;Jane&#x27;, last_name=&#x27;Doe&#x27;, age=29)
Pandas(Index=&#x27;id003&#x27;, first_name=&#x27;Marry&#x27;, last_name=&#x27;Jackson&#x27;, age=37)
Pandas(Index=&#x27;id004&#x27;, first_name=&#x27;Victoria&#x27;, last_name=&#x27;Smith&#x27;, age=52)
Pandas(Index=&#x27;id005&#x27;, first_name=&#x27;Gabriel&#x27;, last_name=&#x27;Brown&#x27;, age=26)
Pandas(Index=&#x27;id006&#x27;, first_name=&#x27;Layla&#x27;, last_name=&#x27;Martinez&#x27;, age=32)
</code></pre>
The <code>itertuples()</code> method has two arguments: <code>index</code> and <code>name</code>.
We can choose not to display index column by setting the <code>index</code> parameter to <code>False</code>:
<pre><code class="hljs">for row in df.itertuples(index=False):
 print(row)
</code></pre>
Our tuples will no longer have the index displayed:
<pre><code class="hljs">Pandas(first_name=&#x27;John&#x27;, last_name=&#x27;Smith&#x27;, age=34)
Pandas(first_name=&#x27;Jane&#x27;, last_name=&#x27;Doe&#x27;, age=29)
Pandas(first_name=&#x27;Marry&#x27;, last_name=&#x27;Jackson&#x27;, age=37)
Pandas(first_name=&#x27;Victoria&#x27;, last_name=&#x27;Smith&#x27;, age=52)
Pandas(first_name=&#x27;Gabriel&#x27;, last_name=&#x27;Brown&#x27;, age=26)
Pandas(first_name=&#x27;Layla&#x27;, last_name=&#x27;Martinez&#x27;, age=32)
</code></pre>
As you've already noticed, this generator yields namedtuples with the default name of <code>Pandas</code>. We can change this by passing <code>People</code> argument to the <code>name</code> parameter. You can choose any name you like, but it's always best to pick names relevant to your data:
<pre><code class="hljs">for row in df.itertuples(index=False, name=&#x27;People&#x27;):
 print(row)
</code></pre>
Now our output would be:
<pre><code class="hljs">People(first_name=&#x27;John&#x27;, last_name=&#x27;Smith&#x27;, age=34)
People(first_name=&#x27;Jane&#x27;, last_name=&#x27;Doe&#x27;, age=29)
People(first_name=&#x27;Marry&#x27;, last_name=&#x27;Jackson&#x27;, age=37)
People(first_name=&#x27;Victoria&#x27;, last_name=&#x27;Smith&#x27;, age=52)
People(first_name=&#x27;Gabriel&#x27;, last_name=&#x27;Brown&#x27;, age=26)
People(first_name=&#x27;Layla&#x27;, last_name=&#x27;Martinez&#x27;, age=32)
</code></pre>
<h2 id="iterationperformancewithpandas">Iteration Performance with Pandas</h2>
The <a rel="nofollow noopener" target="_blank"
href="https://pandas.pydata.org/pandas-docs/stable/user_guide/basics.html#iteration">official Pandas documentation</a> warns that iteration is a slow process. If you're iterating over a <code>DataFrame</code> to modify the data, vectorization would be a quicker alternative. Also, it's discouraged to modify data while iterating over rows as Pandas sometimes returns a copy of the data in the row and not its reference, which means that not all data will actually be changed.
For small datasets you can use the <code>to_string()</code> method to display all the data. For larger datasets that have many columns and rows, you can use <code>head(n)</code> or <code>tail(n)</code> methods to print out the first <code>n</code> rows of your DataFrame (the default value for <code>n</code> is 5).
<h2 id="speedcomparison">Speed Comparison</h2>
To measure the speed of each particular method, we wrapped them into functions that would execute them for 1000 times and return the average time of execution.
To test these methods, we will use both of the <code>print()</code> and <code>list.append()</code> functions to provide better comparison data and to cover common use cases. In order to decide a fair winner, we will iterate over DataFrame and use only 1 value to print or append per loop.
Here's how the return values look like for each method:
For example, while <code>items()</code> would cycle column by column:
<pre><code class="hljs">(&#x27;first_name&#x27;, 
id001 John
id002 Jane
id003 Marry
id004 Victoria
id005 Gabriel
id006 Layla
Name: first_name, dtype: object)
</code></pre>
<code>iterrows()</code> would provide all column data for a particular row:
<pre><code class="hljs">(&#x27;id001&#x27;, 
first_name John
last_name Smith
age 34
Name: id001, dtype: object)
</code></pre>
And finally, a single row for the <code>itertuples()</code> would look like this:
<pre><code class="hljs">Pandas(Index=&#x27;id001&#x27;, first_name=&#x27;John&#x27;, last_name=&#x27;Smith&#x27;, age=34)
</code></pre>
Here are the average results in seconds:
<table class="table table-striped">
 <tr>
 <td>Method</td>
 <td>Speed (s)</td>
 <td>Test Function</td>
 </tr>
 <tr>
 <td>items()</td>
 <td>1.349279541666571</td>
 <td>print()</td>
 </tr>
 <tr>
 <td>iterrows()</td>
 <td>3.4104003086661883</td>
 <td>print()</td>
 </tr>
 <tr>
 <td>itertuples()</td>
 <td>0.41232967500279</td>
 <td>print()</td>
 </tr>
 <tr>
 <td></td>
 <td></td>
 <td></td>
 </tr>
</table>
<table class="table table-striped">
 <tr>
 <td>Method</td>
 <td>Speed (s)</td>
 <td>Test Function</td>
 </tr>
 <tr>
 <td>items()</td>
 <td>0.006637570998767235</td>
 <td>append()</td>
 </tr>
 <tr>
 <td>iterrows()</td>
 <td>0.5749766406661365</td>
 <td>append()</td>
 </tr>
 <tr>
 <td>itertuples()</td>
 <td>0.3058610513350383</td>
 <td>append()</td>
 </tr>
 <tr>
 <td></td>
 <td></td>
 <td></td>
 </tr>
</table>
Printing values will take more time and resource than appending in general and our examples are no exceptions. While <code>itertuples()</code> performs better when combined with <code>print()</code>, <code>items()</code> method outperforms others dramatically when used for <code>append()</code> and <code>iterrows()</code> remains the last for each comparison.
Please note that these test results highly depend on other factors like OS, environment, computational resources, etc. The size of your data will also have an impact on your results.
<h2 id="conclusion">Conclusion</h2>
We've learned how to iterate over the DataFrame with three different Pandas methods - <code>items()</code>, <code>iterrows()</code>, <code>itertuples()</code>. Depending on your data and preferences you can use one of them in your projects.

Marcus Sanatan

Ruslan Hasanov

This tutorial explains how to iterate over rows in a Pandas DataFrame. You'll use the items(), iterrows() and itertuples() functions and look at their performance.

How to Iterate over Rows in a Pandas DataFrame

How to Iterate Over Rows in a Pandas DataFrame

<h2 id="introduction">Introduction</h2>
Lists are useful in different ways compared to other datatypes because of how versatile they are. In this article we'll take a look at one of the most common operations with lists - finding the index of an element.
We will take a look at different scenarios of finding an element, i.e. finding the first, last, and all occurrences of an element. As well as what happens when the element we're looking for doesn't exist.
<h2 id="usingtheindexfunction">Using the index() Function</h2>
All of the operations we mentioned in the last paragraph can be done with the built-in <code>index()</code> function. The syntax for this function is <code>index(element[, start[, end]])</code>.
The <code>element</code> parameter naturally represents the element we're looking for. The <code>start</code> and <code>end</code> parameters are optional and represent the range of indices in which we look for the <code>element</code>.
The default value for <code>start</code> is <code>0</code> (searching from the beginning), and the default value for <code>end</code> is the number of elements in the list (searching to the end of the list).
The function returns the first position of the <code>element</code> in the list that it could find, regardless of how many equal elements there are after the first occurrence.
<h3 id="findingthefirstoccurrenceofanelement">Finding the First Occurrence of an Element</h3>
Using the <code>index()</code> function without setting any values for <code>start</code> and <code>end</code> will give us the first occurrence of the <code>element</code> we're looking for:
<pre><code class="hljs">my_list = [&#x27;a&#x27;, &#x27;b&#x27;, &#x27;c&#x27;, &#x27;d&#x27;, &#x27;e&#x27;, &#x27;1&#x27;, &#x27;2&#x27;, &#x27;3&#x27;, &#x27;b&#x27;]

first_occurrence = my_list.index(&#x27;b&#x27;)
print(&quot;First occurrence of &#x27;b&#x27; in the list: &quot;, first_occurrence)
</code></pre>
Which would give us the expected output:
<pre><code class="hljs">First occurrence of &#x27;b&#x27; in the list: 1
</code></pre>
<h3 id="findingalloccurrencesofanelement">Finding All Occurrences of an Element</h3>
To find all occurrences of an element, we can use the optional parameter <code>start</code> so that we search in only certain segments of the list.
For example, let's say that we would the first occurrence of an element at index <code>3</code>. In order to find the next one, we would need to continue our search for the first appearance of that element after index <code>3</code>. We would repeat this process, changing where our search begins, as long as we found new occurrences of the element:
<pre><code class="hljs">my_list = [&#x27;b&#x27;, &#x27;a&#x27;, 2, &#x27;n&#x27;, False, &#x27;a&#x27;, &#x27;n&#x27;, &#x27;a&#x27;]

all_occurrences = []
last_found_index = -1
element_found = True

while element_found:
 try:
 last_found_index = my_list.index(&#x27;a&#x27;, last_found_index + 1)
 all_occurrences.append(last_found_index)
 except ValueError:
 element_found = False
 
if len(all_occurrences) == 0:
 print(&quot;The element wasn&#x27;t found in the list&quot;)
else:
 print(&quot;The element was found at: &quot; + str(all_occurrences))
</code></pre>
Running this code would give us:
<pre><code class="hljs">The element was found at: [1, 5, 7]
</code></pre>
We had to use a <code>try</code> block here, since the <code>index()</code> function throws an error when it can't find the specified <code>element</code> in the given range. This might be unusual to developers who are more used to other languages since functions like these usually return <code>-1</code>/<code>null</code> when the element can't be found.
However, in Python we have to be careful and use a <code>try</code> block when we use this function.
Another, more neat way of doing this same thing would be by using list comprehension and ignoring the <code>index()</code> function altogether:
<pre><code class="hljs">my_list = [&#x27;b&#x27;, &#x27;a&#x27;, 2, &#x27;n&#x27;, False, &#x27;a&#x27;, &#x27;n&#x27;, &#x27;a&#x27;]

all_occurrences = [index for index, element in enumerate(my_list) if element == &#x27;a&#x27;]

print(&quot;The element was found at: &quot; + str(all_occurrences))
</code></pre>
Which would give us the same output as before. This approach has the added benefit of not using the <code>try</code> block.
<h3 id="findingthelastoccurrenceofanelement">Finding the Last Occurrence of an Element</h3>
If you need to find the last occurrence of an element in the list, there are two approaches you can use with the <code>index()</code> function:
<ul>
<li>Reverse the list and look for the first occurrence in the reversed list</li>
<li>Go through all the occurrences of the element, and only keep track of the last occurrence</li>
</ul>
Regarding the first approach, if we knew the first occurrence of the <code>element</code> in a reversed list, we could find the position of the last occurrence in the original one. More specifically, we can do this by subtracting <code>reversed_list_index - 1</code> from the length of the original list:
<pre><code class="hljs">my_list = [&#x27;b&#x27;, &#x27;a&#x27;, 2, &#x27;n&#x27;, False, &#x27;a&#x27;, &#x27;n&#x27;, &#x27;a&#x27;]

reversed_list_index = my_list[::-1].index(&#x27;n&#x27;)
# or alteratively:
# reversed_list_index2 = list(reversed(my_list)).index(&#x27;n&#x27;)

original_list_index = len(my_list) - 1 - reversed_list_index

print(original_list_index)
</code></pre>
Which would give us the desired output:
<pre><code class="hljs">6
</code></pre>
As for the second approach, we could tweak the code we used to find all occurrences and only keep track of the last occurrence we found:
<pre><code class="hljs">my_list = [&#x27;b&#x27;, &#x27;a&#x27;, 2, &#x27;n&#x27;, False, &#x27;a&#x27;, &#x27;n&#x27;, &#x27;a&#x27;]

last_occurrence = -1
element_found = True

while element_found:
 try:
 last_occurrence = my_list.index(&#x27;n&#x27;, last_occurrence + 1)
 except ValueError:
 element_found = False
 
if last_occurrence == -1:
 print(&quot;The element wasn&#x27;t found in the list&quot;)
else:
 print(&quot;The last occurrence of the element is at: &quot;, last_occurrence)
</code></pre>
Which would give us the same output:
<pre><code class="hljs">6
</code></pre>
<h2 id="conclusion">Conclusion</h2>
We have taken a look at some of the most common uses for the <code>index()</code> function, and how to avoid it in some cases.
Keep the potentially unusual behavior of the <code>index()</code> function in mind, where it throws an error instead of returning <code>-1</code>/<code>None</code> when an element isn't found in the list.

Guest Contributor

In this article we'll take a look at examples of how to get the index of an element in a list with the index() function, for finding the first, last, and all occurrences of an element.

Python: Check Index of an Item in a List

<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 font size in Matplotlib.
<h2 id="changefontsizeinmatplotlib">Change Font Size in Matplotlib</h2>
There are a few ways you can go about changing the size of fonts in Matplotlib. You can set the <code>fontsize</code> argument, change how Matplotlib treats fonts in general, or even changing the <a target="_blank" href="/change-figure-size-in-matplotlib/">figure size</a>.
Let's first create a simple plot that we'll want to change the size of fonts on:
<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;)
ax.set_title(&#x27;Sine and cosine waves&#x27;)
ax.set_xlabel(&#x27;Time&#x27;)
ax.set_ylabel(&#x27;Intensity&#x27;)
leg = ax.legend()

plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/change-font-size-in-matplotlib-1.png" alt="matplotlib plot">
<h3 id="changefontsizeusingfontsize">Change Font Size using fontsize</h3>
Let's try out the simplest option. Every function that deals with text, such as <code>Title</code>, labels and all other textual functions accept an argument - <code>fontsize</code>.
Let's revisit the code from before and specify a <code>fontsize</code> for these elements:
<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;)
ax.set_title(&#x27;Sine and cosine waves&#x27;, fontsize=20)
ax.set_xlabel(&#x27;Time&#x27;, fontsize=16)
ax.set_ylabel(&#x27;Intensity&#x27;, fontsize=16)
leg = ax.legend()

plt.show()
</code></pre>
Here, we've set the <code>fontsize</code> for the title as well as the labels for time and intensity. Running this code yields:
<img src="https://stackabuse.s3.amazonaws.com/media/change-font-size-in-matplotlib-2.png" alt="matplotlib fontsize argument">
We can also change the size of the font in the legend by adding the <code>prop</code> argument and setting the font size there:
<pre><code class="hljs">leg = ax.legend(prop={&quot;size&quot;:16})
</code></pre>
This will change the font size, which in this case also moves the legend to the bottom left so it doesn't overlap with the elements on the top right:
<img src="https://stackabuse.s3.amazonaws.com/media/change-font-size-in-matplotlib-3.png" alt="matplotlib change legend font size">
However, while we can set each font size like this, if we have many textual elements, and just want a uniform, general size - this approach is repetitive.
In such cases, we can turn to setting the font size globally.
<h3 id="changefontsizeglobally">Change Font Size Globally</h3>
There are two ways we can set the font size globally. We'll want to set the <code>font_size</code> parameter to a new size. We can get to this parameter via <code>rcParams['font.size']</code>.
One way is to modify them directly:
<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)

plt.rcParams[&#x27;font.size&#x27;] = &#x27;16&#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;)
plt.xlabel(&#x27;Time&#x27;)
plt.ylabel(&#x27;Intensity&#x27;)
fig.suptitle(&#x27;Sine and cosine waves&#x27;)
leg = ax.legend()

plt.show()
</code></pre>
You have to set these before the <code>plot()</code> function call since if you try to apply them afterwards, no change will be made. This approach will change everything that's specified as a font by the <code>font</code> kwargs object.
However, when we run this code, it's obvious that the x and y ticks, nor the x and y labels didn't change in size:
<img src="https://stackabuse.s3.amazonaws.com/media/change-font-size-in-matplotlib-4.png" alt="matplotlib change font size rc params">
Depending on the Matplotlib version you're running, you won't be able to change these with rc parameters. You'd use <code>axes.labelsize</code> and <code>xtick.labelsize</code>/<code>ytick.labelsize</code> for them respectively.
If setting these doesn't change the size of labels, you can use the <code>set()</code> function passing in a <code>fontsize</code> or use the <code>set_fontsize()</code> function:
<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)

# Set general font size
plt.rcParams[&#x27;font.size&#x27;] = &#x27;16&#x27;

# Set tick font size
for label in (ax.get_xticklabels() + ax.get_yticklabels()):
 label.set_fontsize(16)
 
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.xlabel(&#x27;Time&#x27;, fontsize=16)
plt.ylabel(&#x27;Intensity&#x27;, fontsize=16)

fig.suptitle(&#x27;Sine and cosine waves&#x27;)
leg = ax.legend()

plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/change-font-size-in-matplotlib-5.png" alt="matplotlib change font size xtick and label">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to change the size of fonts in Matplotlib.
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">
 Limited time discount: 2-for-1, save 50%!
 ✅ 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 take a look at how to change the font size in a Matplotlib plot. We'll use the fontsize argument, as well as tweak the rc parameters to change the style.

Change Font Size in Matplotlib

<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 Lists in Python.
<h2 id="slicingalistinpython">Slicing a List in Python</h2>
There are a couple of ways to slice a list, most common of which is by using the <code>:</code> operator with the following syntax:
<pre><code class="hljs">a_list[start:end]
a_list[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>. Note that the item with the index <code>start</code> will be included in the resulting sublist, but the item with the index <code>end</code> won't be. The first element of a list has the index of <code>0</code>.
Example without the <code>step</code> parameter:
<pre><code class="hljs"># A list of strings:
a_list = [&#x27;May&#x27;, &#x27;the&#x27;, &#x27;Force&#x27;, &#x27;be&#x27;, &#x27;with&#x27;, &#x27;you.&#x27;]
sublist = a_list[1:3]
print(sublist)
</code></pre>
This should print:
<pre><code class="hljs">[&#x27;the&#x27;, &#x27;Force&#x27;]
</code></pre>
To skip every other word, set <code>step</code> to <code>2</code>:
<pre><code class="hljs">a_list = [&#x27;The&#x27;, &#x27;Force&#x27;, &#x27;will&#x27;, &#x27;be&#x27;, &#x27;with&#x27;, &#x27;you.&#x27;, &#x27;Always.&#x27;]
sublist = a_list[1:8:2]
print(sublist)
</code></pre>
Output:
<pre><code class="hljs">[&#x27;Force&#x27;, &#x27;be&#x27;, &#x27;you.&#x27;]
</code></pre>
If <code>step</code> isn't listed, the sublist will start from the beginning. Likewise, if <code>end</code> isn't listed, the sublist will end at the ending of the original list:
<pre><code class="hljs">a_list = [&#x27;Do.&#x27;, &#x27;Or&#x27;, &#x27;do&#x27;, &#x27;not.&#x27;, &#x27;There&#x27;, &#x27;is&#x27;, &#x27;no&#x27;, &#x27;try.&#x27;]
sublist = a_list[:4]
print(sublist)
sublist = a_list[4:]
print(sublist)
</code></pre>
That snippet of code prints out:
<pre><code class="hljs">[&#x27;Do.&#x27;, &#x27;Or&#x27;, &#x27;do&#x27;, &#x27;not.&#x27;]
[&#x27;There&#x27;, &#x27;is&#x27;, &#x27;no&#x27;, &#x27;try.&#x27;]
</code></pre>
<h3 id="findingtheheadandtailoflistwithslicenotation">Finding the Head and Tail of List with Slice Notation</h3>
The slice notation can be used with negative indexing as well. Negative indexing works the same way as regular indexing, except for the fact that it starts indexing from the last element which has the index <code>-1</code>.
This can be used to obtain the head and tail of a list of a given length. The head of a list is a sublist that contains the first <code>n</code> elements of a list, and the tail is a sublist that contains the last <code>n</code> elements.
Let's go ahead and separate a tail and head of a list:
<pre><code class="hljs"># The length of the tail
n = 2
a_list = [&#x27;Never&#x27;, &#x27;tell&#x27;, &#x27;me&#x27;, &#x27;the&#x27;, &#x27;odds!&#x27;]

# Head of the list:
sublist = a_list[:n]
print(sublist)

# Tail of the list:
sublist = a_list[-n:]
print(sublist)
</code></pre>
This outputs:
<pre><code class="hljs">[&#x27;Never&#x27;, &#x27;tell&#x27;]
[&#x27;the&#x27;, &#x27;odds!&#x27;]
</code></pre>
<h3 id="usingslicenotationtoreversealist">Using Slice Notation to Reverse a List</h3>
Even the <code>step</code> parameter can be negative. If we set it to a negative value, the resulting list will be reversed, with the <code>step</code> value. Instead of stepping forward, we're stepping backwards, from the end of the list to the start and including these elements:
<pre><code class="hljs">a_list = [&#x27;Power!&#x27;, &#x27;Unlimited&#x27;, &#x27;power!&#x27;]
sublist = a_list[::-1]
print(sublist)
</code></pre>
This results in:
<pre><code class="hljs">[&#x27;power!&#x27;, &#x27;Unlimited&#x27;, &#x27;Power!&#x27;]
</code></pre>
<h3 id="replacingelementsofasublistwithslicenotation">Replacing Elements of a Sublist with Slice Notation</h3>
The slice notation can be used to assign new values to elements of a certain sublist. For example, let try to replace the tail and the head of a list:
<pre><code class="hljs">a_list = [&#x27;I&#x27;, &#x27;am&#x27;, &#x27;no&#x27;, &#x27;Jedi.&#x27;]
print(a_list)
# Replacing the head of a list
a_list[:1] = [&#x27;You&#x27;, &#x27;are&#x27;]
print(a_list)
# Replacing the tail of a list
a_list[-1:] = [&#x27;Sith&#x27;]
print(a_list)
</code></pre>
The expected output is:
<pre><code class="hljs">[&#x27;I&#x27;, &#x27;am&#x27;, &#x27;no&#x27;, &#x27;Jedi.&#x27;]
[&#x27;You&#x27;, &#x27;are&#x27;, &#x27;no&#x27;, &#x27;Jedi.&#x27;]
[&#x27;You&#x27;, &#x27;are&#x27;, &#x27;no&#x27;, &#x27;Sith&#x27;]
</code></pre>
<h3 id="replacingeverynthelementofalistwithslicenotation">Replacing Every n-th Element of a List with Slice Notation</h3>
An easy way to replace every n-th element of a list is to set the <code>step</code> parameter to <code>n</code> in the slicing notation:
<pre><code class="hljs"> a_list = [&#x27;I’m&#x27;, &#x27;just&#x27;, &#x27;a&#x27;, &#x27;simple&#x27;, &#x27;man&#x27;, &#x27;trying&#x27;, &#x27;to&#x27;, &#x27;make&#x27;, &#x27;my&#x27;, &#x27;way&#x27;, &#x27;in&#x27;, &#x27;the&#x27;, &#x27;universe.&#x27;]
 
print(a_list)

# Replacing every other word starting with the word with the index 1
a_list[1::2] = [&#x27;only&#x27;, &#x27;common&#x27;, &#x27;attempting&#x27;,&#x27;do&#x27;, &#x27;best&#x27;,&#x27;the&#x27;]
print(a_list)
</code></pre>
This results in:
<pre><code class="hljs">[&#x27;I’m&#x27;, &#x27;just&#x27;, &#x27;a&#x27;, &#x27;simple&#x27;, &#x27;man&#x27;, &#x27;trying&#x27;, &#x27;to&#x27;, &#x27;make&#x27;, &#x27;my&#x27;, &#x27;way&#x27;, &#x27;in&#x27;, &#x27;the&#x27;, &#x27;universe.&#x27;]
[&#x27;just&#x27;, &#x27;simple&#x27;, &#x27;trying&#x27;, &#x27;make&#x27;, &#x27;way&#x27;, &#x27;the&#x27;]
[&#x27;I’m&#x27;, &#x27;only&#x27;, &#x27;a&#x27;, &#x27;common&#x27;, &#x27;man&#x27;, &#x27;attempting&#x27;, &#x27;to&#x27;, &#x27;do&#x27;, &#x27;my&#x27;, &#x27;best&#x27;, &#x27;in&#x27;, &#x27;the&#x27;, &#x27;universe.&#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 Lists in Python.

Kristina Popovic

In this tutorial, we'll go over examples of the slice notation in Python on lists. We'll slice a list, find tails and heads of a list, reverse a list, replace elements, etc.

Python: Slice Notation on List

<h2 id="introduction">Introduction</h2>
Searching is one of the most commonly performed tasks in the domain of Computer Science. Many algorithms and data structures exist to make searching more efficient.
In this article, we'll look at the idea behind Binary Search and how to implement it in JavaScript.
Binary Search is a very simple, intuitive, yet efficient searching algorithm. The only caveat is that it works only sorted arrays, so some preprocessing on our data in order to sort it might be necessary.
<h2 id="understandingbinarysearch">Understanding Binary Search</h2>
Binary Search is a divide-and-conquer algorithm, that divides the array roughly in half every time it checks whether an element of the array is the one we're looking for.
In other words, we divide the problem into simpler problems until it becomes simple enough to solve them directly. Let's assume we have a sorted array (in ascending order) and take a look at the steps of binary search:
<ol>
<li>Find the middle element of the given array.</li>
<li>Compare the middle element with the value we are looking for (called key).
<ul>
<li>If the key is less than the middle element, search in the left half.</li>
<li>If the key is more than the middle element, search in the right half.</li>
<li>If the key is equal to the middle element, return the index of the middle element.</li>
</ul>
</li>
<li>Continue with steps 1, 2 until we are left with a single element.</li>
<li>If the key is still not found, return -1.</li>
</ol>
To understand this better, let's look at an example of why we can simply discard half of the current search range each time we check an element:
<img src="https://stackabuse.s3.amazonaws.com/media/binary-search-in-python-1.png" alt="binary search example">
Similarly to this first split, we can keep dividing the array until we either find the element, or end up with only one candidate for the key.
<img src="https://stackabuse.s3.amazonaws.com/media/binary-search-in-python-2.png" alt="binary search example">
In this case, we ended up with only one possible candidate for the key, and it turned out to match the element we were looking for.
As you can see in the example, it took us relatively few comparisons to find the element we needed. Namely, we only needed to do four comparisons to find the element in an array of 11 elements. We'll take a closer look at the efficiency of Binary Search later, but it should already be clear that it outclasses simple searching algorithms like <a target="_blank" href="https://stackabuse.com/linear-search-in-javascript">Linear Search</a>.
<h2 id="implementationofbinarysearchinjavascript">Implementation of Binary Search in JavaScript</h2>
Now that we've gone through the logic behind Binary Search let us implement it in JavaScript:
<pre><code class="hljs">function binarySearch(sortedArray, key){
 let start = 0;
 let end = sortedArray.length - 1;

 while (start &lt;= end) {
 let middle = Math.floor((start + end) / 2);

 if (sortedArray[middle] === key) {
 // found the key
 return middle;
 } else if (sortedArray[middle] &lt; key) {
 // continue searching to the right
 start = middle + 1;
 } else {
 // search searching to the left
 end = middle - 1;
 }
 }
 // key wasn&#x27;t found
 return -1;
}
</code></pre>
Here, we are using two variables to keep track of the <code>start</code> and <code>end</code> of the current subarray we are searching. We find the middle element, and then check whether it is equal, lesser than, or greater than the <code>key</code>.
As explained previously, given that we have a sorted array, we can discard half of the elements in the array. We accomplish this in code by changing the <code>start</code> or <code>end</code> variable, depending on where we're continuing our search. If the current element we're looking at is less than the key, we change <code>start</code> to <code>middle + 1</code> and effectively discard the current element and all elements less than that.
<h2 id="theefficiencyofbinarysearch">The Efficiency of Binary Search</h2>
The time complexity of the Binary Search is O(log2n), where n is the number of elements in the array. This is far better compared to the Linear Search, which is of time complexity O(n). Like many other search algorithms, Binary Search is an in-place algorithm. That means that it works directly on the original array without making any copies.
We have to keep in mind however, that Binary Search only works on sorted arrays. The sorting step itself, if using an efficient sorting algorithm, has a complexity of O(nlogn). This means that in most cases, if the array is small, or if we need to search it only once, a brute-force (e.g. Linear Search) algorithm might be better.
Given this, Binary Search really shines when we need to make repeated searches on large arrays. As previously mentioned, we needed only 4 comparisons (comparisons being the most intensive tasks of all search algorithms), for an array of 11 elements. However, if we had an array of 10,000,000 elements, we would only need to check 24 elements, i.e. 0.0002% of the entire array.
<h2 id="conclusion">Conclusion</h2>
In this article, we have taken a look at Binary Search. It's simple, intuitive and efficient logic and implementation make it a very popular algorithm to demonstrate the divide-and-conquer strategy.

Abhilash Kakumanu

In this article, we'll take a look at one of the most popular search algorithms - Binary Search in JavaScript. We'll go through how it works, the implementation, and what makes it so efficient.

Binary Search in JavaScript

<h2 id="introduction">Introduction</h2>
Getting the number of elements in a list in Python is a common operation. For example, you will need to know how many elements the list has whenever you iterate through it. Remember that lists can contain a combination of types, like integers, floats, strings, booleans, other lists, etc. as their elements:
<pre><code class="hljs"># List of just integers
list_a = [12, 5, 91, 18]

# List of integers, floats, strings, booleans
list_b = [4, 1.2, &quot;hello world&quot;, True]
</code></pre>
If we manually count the elements in <code>list_a</code> we get 5 elements overall. If we do the same for <code>list_b</code> we will see that we have 4 elements.
There are different ways to get the number of elements in a list. The approaches vary whether you want to count nested lists as one element or all the elements in the nested lists, or whether you're only interested in top-level unique elements.
<h2 id="builtinfunctionlen">Built-in Function len()</h2>
The most straightforward and common way to get the number of elements in a list is to use the Python built-in function <code>len()</code>.
Let's look at the following example:
<pre><code class="hljs">list_a = [&quot;Hello&quot;, 2, 15, &quot;World&quot;, 34]

number_of_elements = len(list_a)

print(&quot;Number of elements in the list: &quot;, number_of_elements)
</code></pre>
Which prints out:
<pre><code class="hljs">Number of elements in the list: 5
</code></pre>
As the name function suggests, <code>len()</code> returns the length of the list, regardless of the types of elements in it. This method does not count the lengths of any lists within the list, only top-level elements.
<h2 id="usingaforloop">Using a for Loop</h2>
Another way we can do this is to create a function that loops through the list using a <code>for</code> loop. We first initialize the count of the elements to 0 and every time a loop iteration is performed, the count increases by 1.
The loop ends when it iterates over all the elements, therefore the count will represent the total number of elements in the list:
<pre><code class="hljs">list_c = [20, 8.9, &quot;Hi&quot;, 0, &quot;word&quot;, &quot;name&quot;]

def get_number_of_elements(list):
 count = 0
 for element in list:
 count += 1
 return count

print(&quot;Number of elements in the list: &quot;, get_number_of_elements(list_c))
</code></pre>
Running this code will print:
<pre><code class="hljs">Number of elements in the list: 6
</code></pre>
This is a much more verbose solution compared to the <code>len()</code> function, but it is worth going through it as we will see later in the article that the same idea can be applied when we're dealing with a list of lists. Additionally, you might want to perform some operation either on the elements themselves or another operation in general, which is possible here.
<h2 id="getnumberofuniqueelementsinalist">Get Number of Unique Elements in a List</h2>
Lists can have multiple elements, including duplicates. If we want to get the number of elements without duplicates (unique elements) we can use another built-in function <code>set()</code>. This function creates a <code>set</code> object, which rejects all duplicate values.
We then pass that into the <code>len()</code> function to get the number of elements in the <code>set</code>:
<pre><code class="hljs">list_d = [100, 3, 100, &quot;c&quot;, 100, 7.9, &quot;c&quot;, 15]

number_of_elements = len(list_d)
number_of_unique_elements = len(set(list_d))

print(&quot;Number of elements in the list: &quot;, number_of_elements)
print(&quot;Number of unique elements in the list: &quot;, number_of_unique_elements)
</code></pre>
Which prints:
<pre><code class="hljs">Number of elements in the list: 8
Number of unique elements in the list: 5
</code></pre>
We can see that <code>list_d</code> has a total of 8 elements, among which 5 are unique.
<h2 id="listoflistsusinglen">List of Lists using len()</h2>
In the introduction of this article, we saw that elements of lists can be of different data types. However, lists can have, in turn, lists as their elements. For example:
<pre><code class="hljs">list_e = [[90, 4, 12, 2], [], [34, 45, 2], [9,4], &quot;char&quot;, [7, 3, 19]]
</code></pre>
If we use the built-in function <code>len()</code>, the lists count as single elements, so we will have:
<pre><code class="hljs">number_of_elements = len(list_e)

print(&quot;Number of elements in the list of lists: &quot;, number_of_elements) 
</code></pre>
Which prints:
<pre><code class="hljs">Number of elements in the list of lists: 6
</code></pre>
Note that the empty list counts as one element. If a list within a list contains more than one element, they aren't taken into consideration. This is where a <code>for</code> loop can come in handy.
<h2 id="gettotalnumberofelementsinalistcontainingotherlists">Get Total Number of Elements in a List Containing Other Lists</h2>
If we want to count all the elements inside a list containing other lists, we can use a <code>for</code> loop. We can initialize the <code>count</code> variable to 0 and loop through the list. In every loop iteration, <code>count</code> increases by the length of that list.
We will use the built-in function <code>len()</code> to get the length:
<pre><code class="hljs">list_e = [[90, 4, 12, 2], [], [34, 45, 2], [9,4], &quot;char&quot;, [7, 3, 19]]

def get_all_elements_in_list_of_lists(list):
 count = 0
 for element in list_e:
 count += len(element)
 return count

print(&quot;Total number of elements in the list of lists: &quot;, get_all_elements_in_list_of_lists(list_e)) 
</code></pre>
The output is:
<pre><code class="hljs">Total number of elements in the list of lists: 16
</code></pre>
There are a few important things to note in this example. Firstly, this time the empty list did not affect the total count. This is because in every loop we consider the length of the current nested list, and since the length of an empty list is 0, <code>count</code> is increased by 0.
However, you can see that every character of the string <code>&quot;char&quot;</code> counts towards the total number of elements. This is because the <code>len()</code> function acts on the string by returning the number of all its characters. We can avoid this situation by using the same approach as in the section below, which would also allow us to have elements other than lists.
Another fun way of doing the same thing as in the previous example is by using list comprehension:
<pre><code class="hljs">number_of_elements = sum([len(element) for element in list_e])
</code></pre>
This line essentially does two things. First, it creates a new list containing the lengths of all the elements of the original list. In our case that would be <code>[4, 0, 3, 2, 4, 3]</code>. Secondly, it calls the <code>sum()</code> function using the newly generated list as a parameter, which returns the total sum of all the elements, giving us the desired result.
<h2 id="nestedlists">Nested Lists</h2>
Nested lists are lists that are elements of other lists. There can be multiple levels of lists inside one another:
<pre><code class="hljs">list_f = [30, 0.9, [8, 56, 22, [&quot;a&quot;, &quot;b&quot;]], [200, 3, [5, [89], 10]]]
</code></pre>
We can see that <code>[&quot;a&quot;, &quot;b&quot;]</code> is contained in the list <code>[8, 56, 22, [&quot;a&quot;, &quot;b&quot;]]</code>, which, in turn, is contained in the main list <code>[30, 0.9,[200, 3, [5, [89], 10]]]</code>.
Again, we initialize the <code>count</code> variable to 0. If we want to get the overall number of elements in the nested list, we first need to check if the element is a list or not. If it is, we loop inside the list and recursively call the function until there are no nested lists left. All the elements other than lists (integers, strings, etc.) will increase the count by 1.
Note that this is also the solution to the problems caused by the previous approach.
Let's take a look at the code for counting elements in nested lists:
<pre><code class="hljs">list_f = [30, 0.9, [8, 56, 22, [&quot;a&quot;, &quot;hello&quot;]], [200, 3, [5, [89], 10]]]

def get_elements_of_nested_list(element):
 count = 0
 if isinstance(element, list):
 for each_element in element:
 count += get_elements_of_nested_list(each_element)
 else:
 count += 1
 return count

print(&quot;Total number of elements in the nested list: &quot;, get_elements_of_nested_list(list_f))
</code></pre>
Running this code would give us:
<pre><code class="hljs">Total number of elements in the nested list: 12
</code></pre>
Note that we used the built-in function <code>isinstance()</code> that checks if the first argument is an instance of the class given as the second argument. In the function above, it checks if the element is a list.
The first element <code>30</code> is an integer, so the function jumps to the <code>else</code> block and increases the count by 1. When we get to <code>[8, 56, 22, [&quot;a&quot;, &quot;hello&quot;]]</code>, the function recognizes a list, and recursively goes through it to check for other lists.
<h2 id="conclusion">Conclusion</h2>
We saw that according to the type of list we have, there are different ways to get the number of elements. <code>len()</code> is definitely the quickest and simplest function if we have flat lists.
With lists of lists and nested lists, <code>len()</code> will not count the elements inside the lists. In order to do that, we need to loop through the whole list.

Marzia Deodato

In this article we'll take a look at how to get the number of elements in a list in Python. We'll go through examples of getting all elements, unique elements, and elements in nested lists.

Python: Get Number of Elements in a List

Mehreen Saeed

In this article, we'll cover how to generate synthetic data with Python, Numpy and Scikit Learn. We'll generate 1D data, multilabel, multiclass classification and regression data.

Generating Synthetic Data with Numpy and Scikit-Learn

<h2 id="introduction">Introduction</h2>
The amount of textual data on the Internet has significantly increased in the past decades. There's no doubt that the processing of this amount of information must be automated, and the <a rel="nofollow noopener" target="_blank" href="https://textblob.readthedocs.io/en/dev/">TextBlob</a> package is one of the fairly simple ways to perform NLP - Natural Language Processing.
It provides a simple API for diving into common natural language processing (NLP) tasks such as part-of-speech tagging, noun phrase extraction, tokenization, sentiment analysis, classification, translation, and more.
No special technical prerequisites for employing this library are needed. For instance, TextBlob is applicable for both Python 2 and 3. In case you don't have any textual information handy, TextBlob provides the necessary corpora from the <a rel="nofollow noopener" target="_blank" href="https://www.nltk.org/">NLTK</a> database.
<h2 id="installingtextblob">Installing TextBlob</h2>
Let's start out by installing TextBlob and the NLTK corpora:
<pre><code class="hljs">$ pip install -U textblob
$ python -m textblob.download_corpora
</code></pre>
Note: This process can take some time due to a broad number of algorithms and corpora that this library contains.
<h2 id="whatistokenization">What is Tokenization?</h2>
Before going deeper into the field of NLP you should also be able to recognize these key terms:
<ul>
<li>
Corpus (or corpora in plural) - is simply a certain collection of language data (e.g. texts). Corpora are normally used for training different models of text classification or sentiment analysis, for instance.
</li>
<li>
Token - is a final string that is detached from the primary text, or in other words, it's an output of tokenization.
</li>
</ul>
What is tokenization itself?
<blockquote>
Tokenization or word segmentation is a simple process of separating sentences or words from the corpus into small units, i.e. tokens.
</blockquote>
An illustration of this could be the following sentence:
<ul>
<li>
Input (corpus): The evil that men do lives after them
</li>
<li>
Output (tokens): | The | evil | that | men | do | lives | after | them |
</li>
</ul>
Here, the input sentence is tokenized on the basis of spaces between words. You can also tokenize characters from a single word (e.g. a-p-p-l-e from apple) or separate sentences from one text.
Tokenization is one of the basic and crucial stages of language processing. It transforms unstructured textual material into data. This could be applied further in developing various models of machine translation, search engine optimization, or different business inquiries.
<h2 id="implementingtokenizationincode">Implementing Tokenization in Code</h2>
First of all, it's necessary to establish a <code>TextBlob</code> object and define a sample corpus that will be tokenized later. For example, let's try to tokenize a part of the poem If written by R. Kipling:
<pre><code class="hljs">from textblob import TextBlob

# Creating the corpus
corpus = &#x27;&#x27;&#x27;If you can force your heart and nerve and sinew to serve your turn long after they are gone. And so hold on when there is nothing in you except the Will which says to them: &#x27;Hold on!&#x27;
&#x27;&#x27;&#x27;
</code></pre>
Once the object is created, it should be passed as an argument to the <code>TextBlob</code> constructor:
<pre><code class="hljs">blob_object = TextBlob(corpus)
</code></pre>
Once constructed, we can perform various operations on this <code>blob_object</code>. It already contains our corpus, categorized to a degree.
<h3 id="wordtokenization">Word Tokenization</h3>
Finally, to get the tokenized words we simply retrieve the <code>words</code> attribute to the created <code>blob_object</code>. This gives us a list containing <code>Word</code> objects, that behave very similarly to <code>str</code> objects:
<pre><code class="hljs">from textblob import TextBlob

corpus = &#x27;&#x27;&#x27;If you can force your heart and nerve and sinew to serve your turn long after they are gone. And so hold on when there is nothing in you except the Will which says to them: &#x27;Hold on!&#x27;
&#x27;&#x27;&#x27;

blob_object = TextBlob(corpus)

# Word tokenization of the sample corpus
corpus_words = blob_object.words
# To see all tokens
print(corpus_words)
# To count the number of tokens
print(len(corpus_words))
</code></pre>
The output commands should give you the following:
<pre><code class="hljs">[&#x27;If&#x27;, &#x27;you&#x27;, &#x27;can&#x27;, &#x27;force&#x27;, &#x27;your&#x27;, &#x27;heart&#x27;, &#x27;and&#x27;, &#x27;nerve&#x27;, &#x27;and&#x27;, &#x27;sinew&#x27;, &#x27;to&#x27;, &#x27;serve&#x27;, &#x27;your&#x27;, &#x27;turn&#x27;, &#x27;long&#x27;, &#x27;after&#x27;, &#x27;they&#x27;, &#x27;are&#x27;, &#x27;gone&#x27;, &#x27;and&#x27;, &#x27;so&#x27;, &#x27;hold&#x27;, &#x27;on&#x27;, &#x27;when&#x27;, &#x27;there&#x27;, &#x27;is&#x27;, &#x27;nothing&#x27;, &#x27;in&#x27;, &#x27;you&#x27;, &#x27;except&#x27;, &#x27;the&#x27;, &#x27;Will&#x27;, &#x27;which&#x27;, &#x27;says&#x27;, &#x27;to&#x27;, &#x27;them&#x27;, &#x27;Hold&#x27;, &#x27;on&#x27;]
38
</code></pre>
It's worth noting that this approach tokenizes words using <code>SPACE</code> as the delimiting character. We can change this delimiter, for example, to a <code>TAB</code>:
<pre><code class="hljs">from textblob import TextBlob
from nltk.tokenize import TabTokenizer

corpus = &#x27;&#x27;&#x27;If you can force your heart and nerve and sinew to serve your turn long after they are gone. 	And so hold on when there is nothing in you except the Will which says to them: &#x27;Hold on!&#x27;
&#x27;&#x27;&#x27;

tokenizer = TabTokenizer()
blob_object = TextBlob(corpus, tokenizer = tokenizer)

# Word tokenization of the sample corpus
corpus_words = blob_object.tokens
# To see all tokens
print(corpus_words)
</code></pre>
Note that we've added a <code>TAB</code> after the first sentence here. How, the corpus of the words looks something like:
<pre><code class="hljs">[&#x27;If you can force your heart and nerve and sinew to serve your turn long after they are gone.&#x27;,&#x27;And so hold on when there is nothing in you except the Will which says to them: &#x27;Hold on!&#x27;]
</code></pre>
<code>nltk.tokenize</code> contains other tokenization options as well. By default, it uses the <code>SpaceTokenizer</code> which you don't need to define explicitly, but can. Other than these two, it also contains useful tokenizers such as <code>LineTokenizer</code>, <code>BlankLineTokenizer</code> and <code>WordPunctTokenizer</code>.
A full list can be found in their <a rel="nofollow noopener" target="_blank" href="https://www.nltk.org/_modules/nltk/tokenize.html">documentation</a>.
<h3 id="sentencetokenization">Sentence Tokenization</h3>
To tokenize on a sentence-level, we'll use the same <code>blob_object</code>. This time, instead of the <code>words</code> attribute, we will use the <code>sentences</code> attribute. This returns a list of <code>Sentence</code> objects:
<pre><code class="hljs">from textblob import TextBlob

corpus = &#x27;&#x27;&#x27;If you can force your heart and nerve and sinew to serve your turn long after they are gone. And so hold on when there is nothing in you except the Will which says to them: &#x27;Hold on!&#x27;
&#x27;&#x27;&#x27;

blob_object = TextBlob(corpus)

# Sentence tokenization of the sample corpus
corpus_sentence = blob_object.sentences
# To identify all tokens
print(corpus_sentence)
# To count the number of tokens
print(len(corpus_sentence))
</code></pre>
Output:
<pre><code class="hljs">[Sentence(&quot;If you can force your heart and nerve and sinew to serve your turn long after they are gone&quot;), Sentence(&quot;And so hold on when there is nothing in you except the Will which says to them: &#x27;Hold on!&quot;)]
2
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Tokenization is a very important data preprocessing step in NLP and involves breaking down text into smaller chunks called tokens. These tokens can be individual words, sentences or characters in the original text.
TextBlob is a great library to get into NLP with since it offers a simple API that lets users quickly jump into performing NLP tasks.
In this article, we discussed just one of the NLP tasks that TextBlob deals with, but in a next series, we will take a look at how to solve more complex issues, such as dealing with word inflections, plural and singular forms of words, and more.

Natalia Kuzminykh

In this article we'll take a look at how to tokenize a given text using the TextBlob library. We'll also go through examples of how to tokenize words and sentences.

Simple NLP in Python With TextBlob: Tokenization

<h2 id="introduction">Introduction</h2>
Matplotlib is one of the most widely used data visualization libraries in Python. Typically, when visualizing more than one variable, you'll want to add a legend to the plot, explaining what each variable represents.
In this article, we'll take a look at how to add a legend to a Matplotlib plot.
<h2 id="creatingaplot">Creating a Plot</h2>
Let's first create a simple plot with two variables:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

fig, ax = plt.subplots()

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

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

plt.show()
</code></pre>
Here, we've plotted a sine function, starting at <code>0</code> and ending at <code>10</code> with a step of <code>0.1</code>, as well as a cosine function in the same interval and step. Running this code yields:
<img src="https://stackabuse.s3.amazonaws.com/media/add-a-legend-to-figure-in-matplotlib-1.png" alt="sine visualization python">
Now, it would be very useful to label these and add a legend so that someone who didn't write this code can more easily discern which is which.
<h2 id="addlegendtoafigureinmatplotlib">Add Legend to a Figure in Matplotlib</h2>
Let's add a legend to this plot. Firstly, we'll want to <code>label</code> these variables, so that we can refer to those labels in the legend. Then, we can simply call <code>legend()</code> on the <code>ax</code> object for the legend to be added:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

fig, ax = plt.subplots()

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;)
leg = ax.legend()

plt.show()
</code></pre>
Now, if we run the code, the plot will have a legend:
<img src="https://stackabuse.s3.amazonaws.com/media/add-a-legend-to-figure-in-matplotlib-2.png" alt="add legend to matplotlib plot">
Notice how the legend was automatically placed in the only free space where the waves won't run over it.
<h3 id="customizelegendinmatplotlib">Customize Legend in Matplotlib</h3>
The legend is added, but it's a little bit cluttered. Let's remove the border around it and move it to another location, as well as <a target="_blank" href="/change-figure-size-in-matplotlib/">change the plot's size</a>:
<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;)
leg = ax.legend(loc=&#x27;upper right&#x27;, frameon=False)

plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/add-a-legend-to-figure-in-matplotlib-3.png" alt="customizing legend in matplotlib">
Here, we've used the <code>loc</code> argument to specify that we'd like to put the legend in the top right corner. Other values that are accepted are <code>upper left</code>, <code>lower left</code>, <code>upper right</code>, <code>lower right</code>, <code>upper center</code>, <code>lower center</code>, <code>center left</code> and <code>center right</code>.
Additionally, you can use <code>center</code> to put it in the dead center, or <code>best</code> to place the legend at the &quot;best&quot; free spot so that it doesn't overlap with any of the other elements. By default, <code>best</code> is selected.
<h3 id="addlegendoutsideofaxes">Add Legend Outside of Axes</h3>
Sometimes, it's tricky to place the legend within the border box of a plot. Perhaps, there are many elements going on and the entire box is filled with important data.
In such cases, you can place the legend outside of the axes, and away from the elements that constitute it. This is done via the <code>bbox_to_anchor</code> argument, which specifies where we want to anchor the legend to:
<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;)
leg = ax.legend(loc=&#x27;center&#x27;, bbox_to_anchor=(0.5, -0.10), shadow=False, ncol=2)

plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/add-a-legend-to-figure-in-matplotlib-4.png" alt="add legend outside of axes">
The <code>bbox_to_anchor</code> argument accepts a few arguments itself. Firstly, it accepts a tuple, which allows up to 4 elements. Here, we can specify the <code>x</code>, <code>y</code>, <code>width</code> and <code>height</code> of the legend.
We've only set the <code>x</code> and <code>y</code> values, to displace it <code>-0.10</code> below the axes, and <code>0.5</code> from the left side (<code>0</code> being the left hand of the box and <code>1</code> the right hand side).
By tweaking these, you can set the legend at any place. Within or outside of the box.
Then, we've set the <code>shadow</code> to <code>False</code>. This is used to specify whether we want a small shadow rendered below the legend or not.
Finally, we've set the <code>ncol</code> argument to <code>2</code>. This specifies the number of labels in a column. Since we have two labels and want them to be in one column, we've set it to <code>2</code>. If we changed this argument to <code>1</code>, they'd be placed one above the other:
<img src="https://stackabuse.s3.amazonaws.com/media/add-a-legend-to-figure-in-matplotlib-5.png" alt="add legend outside of axes with one col">
Note: The <code>bbox_to_anchor</code> argument is used alongside the <code>loc</code> argument. The <code>loc</code> argument will put the legend based on the <code>bbox_to_anchor</code>. In our case, we've put it in the <code>center</code> of the new, displaced, location of the border box.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over how to add a legend to your Matplotlib plots. Firstly, we've let Matplotlib figure out where the legend should be located, after which we've used the <code>bbox_to_anchor</code> argument to specify our own location, outside of the axes.
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">
 Limited time discount: 2-for-1, save 50%!
 ✅ 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>

In this tutorial, we'll go over a few examples of how to add a legend to a Matplotlib figure/plot. We'll also add a legend outside of the axes using bbox_to_anchor with loc.