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

David Landup

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.

Matplotlib Scatter Plot - Tutorial and Examples

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

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.

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.