<h2 id="introduction">Introduction</h2>
Seaborn is one of the most widely used data visualization libraries in Python, as an extension to Matplotlib. It offers a simple, intuitive, yet highly customizable API for data visualization.
In this tutorial, we'll take a look at how to plot a Bar Plot in Seaborn.
Bar graphs display numerical quantities on one axis and categorical variables on the other, letting you see how many occurrences there are for the different categories.
<blockquote>
Bar charts can be used for visualizing a time series, as well as just categorical data.
</blockquote>
<h2 id="plotabarplotinseaborn">Plot a Bar Plot in Seaborn</h2>
Plotting a Bar Plot in Seaborn is as easy as calling the <code>barplot()</code> function on the <code>sns</code> instance, and passing in the categorical and continuous variables that we'd like to visualize:
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

sns.set_style(&#x27;darkgrid&#x27;)

x = [&#x27;A&#x27;, &#x27;B&#x27;, &#x27;C&#x27;]
y = [1, 5, 3]

sns.barplot(x, y)
plt.show()
</code></pre>
Here, we've got a few categorical variables in a list - <code>A</code>, <code>B</code> and <code>C</code>. We've also got a couple of continuous variables in another list - <code>1</code>, <code>5</code> and <code>3</code>. The relationship between these two is then visualized in a Bar Plot by passing these two lists to <code>sns.barplot()</code>.
This results in a clean and simple bar graph:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-bar-plot-tutorial-and-examples-1.png" alt="basic bar plot in seaborn">
Though, more often than not, you'll be working with datasets that contain much more data than this. Sometimes, operations are applied to this data, such as ranging or counting certain occurrences.
Whenever you're dealing with means of data, you'll have some error padding that can arise from it. Thankfully, Seaborn has us covered, and applies error bars for us automatically, as it by default calculates the mean of the data we provide.
Let's import the classic Titanic Dataset and visualize a Bar Plot with data from there:
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

# Set Seaborn style
sns.set_style(&#x27;darkgrid&#x27;)
# Import Data
titanic_dataset = sns.load_dataset(&quot;titanic&quot;)

# Construct plot
sns.barplot(x = &quot;sex&quot;, y = &quot;survived&quot;, data = titanic_dataset)
plt.show()
</code></pre>
This time around, we've assigned <code>x</code> and <code>y</code> to the <code>sex</code> and <code>survived</code> columns of the dataset, instead of the hard-coded lists.
If we print the head of the dataset:
<pre><code class="hljs">print(titanic_dataset.head())
</code></pre>
We're greeted with:
<pre><code class="hljs"> survived pclass sex age sibsp parch fare ...
0 0 3 male 22.0 1 0 7.2500 ...
1 1 1 female 38.0 1 0 71.2833 ...
2 1 3 female 26.0 0 0 7.9250 ...
3 1 1 female 35.0 1 0 53.1000 ...
4 0 3 male 35.0 0 0 8.0500 ...

[5 rows x 15 columns]
</code></pre>
Make sure you match the names of these features when you assign <code>x</code> and <code>y</code> variables.
Finally, we use the <code>data</code> argument and pass in the dataset we're working with and from which the features are extracted from. This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-bar-plot-tutorial-and-examples-2.png" alt="plot bar plot from dataset in seaborn">
<h2 id="plotahorizontalbarplotinseaborn">Plot a Horizontal Bar Plot in Seaborn</h2>
To plot a Bar Plot horizontally, instead of vertically, we can simply switch the places of the <code>x</code> and <code>y</code> variables.
This will make the categorical variable be plotted on the Y-axis, resulting in a horizontal plot:
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

x = [&#x27;A&#x27;, &#x27;B&#x27;, &#x27;C&#x27;]
y = [1, 5, 3]

sns.barplot(y, x)
plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-bar-plot-tutorial-and-examples-3.png" alt="plot horizontal bar plot seaborn">
Going back to the Titanic example, this is done in much the same way:
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

titanic_dataset = sns.load_dataset(&quot;titanic&quot;)

sns.barplot(x = &quot;survived&quot;, y = &quot;class&quot;, data = titanic_dataset)
plt.show()
</code></pre>
Which results in:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-bar-plot-tutorial-and-examples-4.png" alt="plot horizontal bar plot of dataset seaborn">
<h2 id="changebarplotcolorinseaborn">Change Bar Plot Color in Seaborn</h2>
Changing the color of the bars is fairly easy. The <code>color</code> argument accepts a Matplotlib color and applies it to all elements.
Let's change them to <code>blue</code>:
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

x = [&#x27;A&#x27;, &#x27;B&#x27;, &#x27;C&#x27;]
y = [1, 5, 3]

sns.barplot(x, y, color=&#x27;blue&#x27;)
plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-bar-plot-tutorial-and-examples-5.png" alt="change bar plot color in seaborn">
Or, better yet, you can set the <code>palette</code> argument, which accepts <a rel="nofollow noopener" target="_blank" href="https://seaborn.pydata.org/tutorial/color_palettes.html">a wide variety of palettes</a>. A pretty common one is <code>hls</code>:
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

titanic_dataset = sns.load_dataset(&quot;titanic&quot;)

sns.barplot(x = &quot;embark_town&quot;, y = &quot;survived&quot;, palette = &#x27;hls&#x27;, data = titanic_dataset)
plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-bar-plot-tutorial-and-examples-6.png" alt="set color palette in seaborn bar plot">
<h2 id="plotgroupedbarplotinseaborn">Plot Grouped Bar Plot in Seaborn</h2>
Grouping Bars in plots is a common operation. Say you wanted to compare some common data, like, the survival rate of passengers, but would like to group them with some criteria.
We might want to visualize the relationship of passengers who survived, segregated into classes (first, second and third), but also factor in which town they embarked from.
This is a fair bit of information in a plot, and it can easily all be put into a simple Bar Plot.
To group bars together, we use the <code>hue</code> argument. Technically, as the name implies, the <code>hue</code> argument tells Seaborn how to color the bars, but in the coloring process, it groups together relevant data.
Let's take a look at the example we've just discussed:
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

titanic_dataset = sns.load_dataset(&quot;titanic&quot;)

sns.barplot(x = &quot;class&quot;, y = &quot;survived&quot;, hue = &quot;embark_town&quot;, data = titanic_dataset)
plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-bar-plot-tutorial-and-examples-7.png" alt="plot grouped bar plot in seaborn">
Now, the error bars for the Queenstown data are pretty large. This indicates that the data on passengers who survived, and embarked from Queenstown varies a lot for the first and second class.
<h2 id="orderinggroupedbarsinabarplotwithseaborn">Ordering Grouped Bars in a Bar Plot with Seaborn</h2>
You can change the order of the bars from the default order (whatever Seaborn thinks makes most sense) into something you'd like to highlight or explore.
This is done via the <code>order</code> argument, which accepts a list of the values and the order you'd like to put them in.
For example, so far, it ordered the classes from the first to the third. What if we'd like to do it the other way around?
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

titanic_dataset = sns.load_dataset(&quot;titanic&quot;)

sns.barplot(x = &quot;class&quot;, y = &quot;survived&quot;, hue = &quot;embark_town&quot;, order = [&quot;Third&quot;, &quot;Second&quot;, &quot;First&quot;], data = titanic_dataset)
plt.show()
</code></pre>
Running this code results in:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-bar-plot-tutorial-and-examples-8.png" alt="ordering grouped bar plots in seaborn">
<h2 id="changeconfidenceintervalonseabornbarplot">Change Confidence Interval on Seaborn Bar Plot</h2>
You can also easily fiddle around with the confidence interval by setting the <code>ci</code> argument.
For example, you can turn it off, by setting it to <code>None</code>, or use standard deviation instead of the mean by setting <code>sd</code>, or even put a cap size on the error bars for aesthetic purposes by setting <code>capsize</code>.
Let's play around with the confidence interval attribute a bit:
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

titanic_dataset = sns.load_dataset(&quot;titanic&quot;)

sns.barplot(x = &quot;class&quot;, y = &quot;survived&quot;, hue = &quot;embark_town&quot;, ci = None, data = titanic_dataset)
plt.show()
</code></pre>
This now removes our error bars from before:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-bar-plot-tutorial-and-examples-9.png" alt="change confidence interval of error bars in seaborn">
Or, we could use standard deviation for the error bars and set a cap size:
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

titanic_dataset = sns.load_dataset(&quot;titanic&quot;)

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

David Landup

In this tutorial, we'll go over how to plot a bar plot with Seaborn and Python. We'll go over basic bar plots, as well as customize them, how to group and order bars, etc.

Seaborn Bar Plot - Tutorial and Examples

<h2 id="introduction">Introduction</h2>
The constant growth of data on the Internet creates a demand for tools that process textual information.
Moreover, it's highly important that this instrument of text analysis could implement solutions for both low and high-level NLP tasks such as counting word frequencies, calculating sentiment analysis of the texts or detecting patterns in relationships between words.
<a rel="nofollow noopener" target="_blank" href="https://textblob.readthedocs.io/en/dev/">TextBlob</a> is a great lightweight library for a wide variety of NLP tasks.
In this tutorial we will shed some light how to perform N-Grams Detection in Python using TextBlob.
<h2 id="whatarengrams">What are N-Grams?</h2>
N-grams represent a continuous sequence of N elements from a given set of texts. In broad terms, such items do not necessarily stand for strings of words, they also can be phonemes, syllables or letters, depending on what you'd like to accomplish.
However, in Natural Language Processing it is more commonly referring to N-grams as strings of words, where n stands for an amount of words that you are looking for.
The following types of N-grams are usually distinguished:
<ul>
<li>
Unigram - An N-gram with simply one string inside (for example, it can be a unique word - YouTube or TikTok from a given sentence e.g. YouTube is launching a new short-form video format that seems an awful lot like TikTok).
</li>
<li>
2-gram or Bigram - Typically a combination of two strings or words that appear in a document: short-form video or video format will be likely a search result of bigrams in a certain corpus of texts (and not format video, video short-form as the word order remains the same).
</li>
<li>
3-gram or Trigram - An N-gram containing up to three elements that are processed together (e.g. short-form video format or new short-form video) etc.
</li>
</ul>
N-grams found its primary application in an area of probabilistic language models. As they estimate the probability of the next item in a word sequence.
This approach for language modeling assumes a tight relationship between the position of each element in a string, calculating the occurrence of the next word with respect to the previous one. In particular, the N-gram model determines the probability as follows - <code>N-1</code>.
For instance, a trigram model (with N = 3) will predict the next word in a string based on the preceding two words as <code>N-1 = 2</code>.
The other cases of implementation of N-grams models in the industry can be detection of plagiarism, where N-grams obtained from two different texts are compared with each other to figure out the degree of similarity of the analyzed documents.
<h2 id="ngramdetectioninpythonusingtextblob">N-gram Detection in Python Using TextBlob</h2>
<h3 id="analysisofasentence">Analysis of a Sentence</h3>
To start out detecting the N-grams in Python, you will first have to install the TexBlob package.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: This library is applicable for both Python 2 and Python 3.

 </div>
 </div>
 </div>
 We'll also want to download the required text corpora for it to work with:
<pre><code class="hljs">$ pip install -U textblob 
$ python -m textblob.download_corpora
</code></pre>
Once the environment is set up, you are ready to load the package and compute N-grams in a sample sentence. In the beginning, we will look at N-grams in the quote of M. Mullenweg: Technology is best when it brings people together.
Let's get started:
<pre><code class="hljs">from textblob import TextBlob

# Sample sentence for N-gram detection
sentence = &quot;Technology is best when it brings people together&quot;
</code></pre>
We've created a <code>sentence</code> string containing the sentence we want to analyze. We've then passed that string to the <code>TextBlob</code> constructor, injecting it into the <code>TextBlob</code> instance that we'll run operations on:
<pre><code class="hljs">ngram_object = TextBlob(sentence)
</code></pre>
Now, let's run N-gram detection. For starters, let's do 2-gram detection. This is specified in the argument list of the <code>ngrams()</code> function call:
<pre><code class="hljs">ngrams = ngram_object.ngrams(n=2) # Computing Bigrams
print(ngrams) 
</code></pre>
The <code>ngrams()</code> function returns a list of tuples of n successive words. In our sentence, a bigram model will give us the following set of strings:
<pre><code class="hljs">[WordList([&#x27;Technology&#x27;, &#x27;is&#x27;]), 
WordList([&#x27;is&#x27;, &#x27;best&#x27;]), 
WordList([&#x27;best&#x27;, &#x27;when&#x27;]), 
WordList([&#x27;when&#x27;, &#x27;it&#x27;]), 
WordList([&#x27;it&#x27;, &#x27;brings&#x27;]), 
WordList([&#x27;brings&#x27;, &#x27;people&#x27;]), 
WordList([&#x27;people&#x27;, &#x27;together&#x27;])]
</code></pre>
<h3 id="documentanalysis">Document Analysis</h3>
Despite the simple nature of this Python library, TextBlob also provides a range of advanced features for analysis. More often than not, we aren't working with single sentences for N-grams detection. It's much more common to work with documents, articles or larger corporas.
In our next example, we will use <a rel="nofollow noopener" target="_blank" href="https://www.cnbc.com/2020/10/15/bill-gates-antitrust-should-look-at-tech-companies-separately.html">an article</a> from the CNBC news portal regarding Bill Gates.
Let's create a text document and call it something along the lines of <code>Input.txt</code> for the next analysis:
<pre><code class="hljs">import sys

# Opening and reading the `Input.txt` file
corpus = open(&quot;Input.txt&quot;).read()
</code></pre>
Then, as usual, we'll instantiate a <code>TextBlob</code> instance, by passing the <code>corpus</code> to the constructor, and run the <code>ngrams()</code> function:
<pre><code class="hljs">ngram_object = TextBlob(corpus)
trigrams = ngram_object.ngrams(n=3) # Computing Trigrams
print(trigrams) 
</code></pre>
This will print out the Trigrams of the content we've provided. However, note that the output can differ depending on the approach you apply to handle punctuation marks:
<pre><code class="hljs">[WordList([&#x27;Bill&#x27;, &#x27;Gates&#x27;, &#x27;says&#x27;]), 
WordList([&#x27;Gates&#x27;, &#x27;says&#x27;, &#x27;that&#x27;]),
WordList([&#x27;says&#x27;, &#x27;that&#x27;, &#x27;antitrust&#x27;]), 
WordList([&#x27;that&#x27;, &#x27;antitrust&#x27;, &#x27;regulators&#x27;]),
WordList([&#x27;antitrust&#x27;, &#x27;regulators&#x27;, &#x27;should&#x27;])
&lt;...&gt;]
</code></pre>
In comparison, Bigram analysis for the given article will provide us a different list:
<pre><code class="hljs">ngram_object = TextBlob(corpus)
Bigram = ngram_object.ngrams(n=) # Computing Bigrams
print(Bigram) 
</code></pre>
A snippet from the output:
<pre><code class="hljs">[WordList([&#x27;Bill&#x27;, &#x27;Gates&#x27;]),
WordList([&#x27;Gates&#x27;, &#x27;says&#x27;]),
WordList([&#x27;says&#x27;, &#x27;that&#x27;]),
WordList([&#x27;that&#x27;, &#x27;antitrust&#x27;]),
WordList([&#x27;antitrust&#x27;, &#x27;regulators&#x27;])
&lt;...&gt;]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
N-Grams detection is a simple and common task in a lot of NLP projects. In this article, we've gone over how to perform N-Gram detection in Python using TextBlob.

Natalia Kuzminykh

In this tutorial, we'll go over the theory and examples on how to perform N-Grams detection in Python using TextBlob for NLP tasks and projects.

Simple NLP in Python with TextBlob: N-Grams Detection

<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 tutorial, we'll take a look at how to plot a bar plot in Matplotlib.
Bar graphs display numerical quantities on one axis and categorical variables on the other, letting you see how many occurrences there are for the different categories.
<blockquote>
Bar charts can be used for visualizing a time series, as well as just categorical data.
</blockquote>
<h2 id="plotabarplotinmatplotlib">Plot a Bar Plot in Matplotlib</h2>
Plotting a Bar Plot in Matplotlib is as easy as calling the <code>bar()</code> function on the PyPlot instance, and passing in the categorical and numerical variables that we'd like to visualize.
<pre><code class="hljs">import matplotlib.pyplot as plt

x = [&#x27;A&#x27;, &#x27;B&#x27;, &#x27;C&#x27;]
y = [1, 5, 3]

plt.bar(x, y)
plt.show()
</code></pre>
Here, we've got a few categorical variables in a list - <code>A</code>, <code>B</code> and <code>C</code>. We've also got a couple of continuous variables in another list - <code>1</code>, <code>5</code> and <code>3</code>. The relationship between these two is then visualized in a Bar Plot by passing these two lists to <code>plt.bar()</code>.
This results in a clean and simple bar graph:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-bar-plot-tutorial-and-examples-1.png" alt="basic bar plot in matplotlib">
<h2 id="plotahorizontalbarplotinmatplotlib">Plot a Horizontal Bar Plot in Matplotlib</h2>
Oftentimes, we might want to plot a Bar Plot horizontally, instead of vertically. This is easily achievable by switching the <code>plt.bar()</code> call with the <code>plt.barh()</code> call:
<pre><code class="hljs">import matplotlib.pyplot as plt

x = [&#x27;A&#x27;, &#x27;B&#x27;, &#x27;C&#x27;]
y = [1, 5, 3]

plt.barh(x, y)
plt.show()
</code></pre>
This results in a horizontally-oriented Bar Plot:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-bar-plot-tutorial-and-examples-2.png" alt="horizontal bar plot in matplotlib">
<h2 id="changebarplotcolorinmatplotlib">Change Bar Plot Color in Matplotlib</h2>
Changing the color of the bars themselves is as easy as setting the <code>color</code> argument with a list of colors. If you have more bars than colors in the list, they'll start being applied from the first color again:
<pre><code class="hljs">import matplotlib.pyplot as plt

x = [&#x27;A&#x27;, &#x27;B&#x27;, &#x27;C&#x27;]
y = [1, 5, 3]

plt.bar(x, y, color=[&#x27;red&#x27;, &#x27;blue&#x27;, &#x27;green&#x27;])
plt.show()
</code></pre>
Now, we've got a nicely colored Bar Plot:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-bar-plot-tutorial-and-examples-3.png" alt="change bar plot color in matplotlib">
Of course, you can also use the shorthand versions or even HTML codes:
<pre><code class="hljs">plt.bar(x, y, color=[&#x27;red&#x27;, &#x27;blue&#x27;, &#x27;green&#x27;])
plt.bar(x, y, color=[&#x27;r&#x27;, &#x27;b&#x27;, &#x27;g&#x27;])
plt.bar(x, y, color=[&#x27;#ff0000&#x27;, &#x27;#00ff00&#x27;, &#x27;#0000ff&#x27;])
plt.show()
</code></pre>
Or you can even put a single scalar value, to apply it to all bars:
<pre><code class="hljs">plt.bar(x, y, color=&#x27;green&#x27;)
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-bar-plot-tutorial-and-examples-4.png" alt="change bar plot color in matplotlib">
<h2 id="barplotwitherrorbarsinmatplotlib">Bar Plot with Error Bars in Matplotlib</h2>
When you're plotting mean values of lists, which is a common application for Bar Plots, you'll have some error space. It's very useful to plot error bars to let other observers, and yourself, know how truthful these means are and which deviation is expected.
For this, let's make a dataset with some values, <a target="_blank" href="/calculating-mean-median-and-mode-in-python/">calculate their means</a> and <a target="_blank" href="/calculating-variance-and-standard-deviation-in-python/">standard deviations</a> with NumPy and plot them with error bars:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.array([4, 5, 6, 3, 6, 5, 7, 3, 4, 5])
y = np.array([3, 4, 1, 3, 2, 3, 3, 1, 2, 3])
z = np.array([6, 9, 8, 7, 9, 8, 9, 6, 8, 7])

x_mean = np.mean(x)
y_mean = np.mean(y)
z_mean = np.mean(z)

x_deviation = np.std(x)
y_deviation = np.std(y)
z_deviation = np.std(z)

bars = [x_mean, y_mean, z_mean]
bar_categories = [&#x27;X&#x27;, &#x27;Y&#x27;, &#x27;Z&#x27;]
error_bars = [x_deviation, y_deviation, z_deviation]

plt.bar(bar_categories, bars, yerr=error_bars)
plt.show()
</code></pre>
Here, we've created three fake datasets with several values each. We'll visualize the mean values of each of these lists. However, since means, as well as averages can give the false sense of accuracy, we'll also calculate the standard deviation of these datasets so that we can add those as error bars.
Using NumPy's <code>mean()</code> and <code>std()</code> functions, this is a breeze. Then, we've packed the bar values into a <code>bars</code> list, the bar names for a nice user experience into <code>bar_categories</code> and finally - the standard deviation values into an <code>error_bars</code> list.
To visualize this, we call the regular <code>bar()</code> function, passing in the <code>bar_categories</code> (categorical values) and <code>bars</code> (continuous values), alongside the <code>yerr</code> argument.
Since we're plotting vertically, we're using the <code>yerr</code> argument. If we were plotting horizontally, we'd use the <code>xerr</code> argument. Here, we've provided the information about the error bars.
This ultimately results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-bar-plot-tutorial-and-examples-5.png" alt="bar plot with error bars in matplotlib">
<h2 id="plotstackedbarplotinmatplotlib">Plot Stacked Bar Plot in Matplotlib</h2>
Finally, let's plot a Stacked Bar Plot. Stacked Bar Plots are really useful if you have groups of variables, but instead of plotting them one next to the other, you'd like to plot them one on top of the other.
For this, we'll again have groups of data. Then, we'll calculate their standard deviation for error bars.
Finally, we'll need an index range to plot these variables on top of each other, while maintaining their relative order. This index will essentially be a range of numbers the length of all the groups we've got.
To stack a bar on another one, you use the <code>bottom</code> argument. You specify what's on the <code>bottom</code> of that bar. To plot <code>x</code> beneath <code>y</code>, you'd set <code>x</code> as the <code>bottom</code> of <code>y</code>.
For more than one group, you'll want to add the values together before plotting, otherwise, the Bar Plot won't add up. We'll use NumPy's <code>np.add().tolist()</code> to add the elements of two lists and produce a list back:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

# Groups of data, first values are plotted on top of each other
# Second values are plotted on top of each other, etc
x = [1, 3, 2]
y = [2, 3, 3]
z = [7, 6, 8]

# Standard deviation rates for error bars
x_deviation = np.std(x)
y_deviation = np.std(y)
z_deviation = np.std(z)

bars = [x, y, z]
ind = np.arange(len(bars))
bar_categories = [&#x27;X&#x27;, &#x27;Y&#x27;, &#x27;Z&#x27;];
bar_width = 0.5
bar_padding = np.add(x, y).tolist()

plt.bar(ind, x, yerr=x_deviation, width=bar_width)
plt.bar(ind, y, yerr=y_deviation, bottom=x, width=bar_width)
plt.bar(ind, z, yerr=z_deviation, bottom=bar_padding, width=bar_width)

plt.xticks(ind, bar_categories)
plt.xlabel(&quot;Stacked Bar Plot&quot;)

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

In this tutorial, we'll go over how to plot a bar plot in Matplotlib and Python. We'll go over basic bar plots, as well as customize them and advanced stacked bar plots with examples.

Matplotlib Bar Plot - Tutorial and Examples

<h2 id="introduction">Introduction</h2>
Java's object-oriented code structure can make referencing variables in multiple places more difficult. It can also be difficult at times to decide which class a given variable should be a part of, especially if it's a widely used value like a database connector or mathematical constant.
In many languages, when faced with a problem like this, we can declare a global variable. Though, unfortunately, Java doesn't technically allow the creation of variables in a global scope.
In this article, we'll go over emulating and using global variables in Java.
<h2 id="whatisaglobalvariable">What is a Global Variable?</h2>
A global variable is a variable which can be accessed from any scope. Many programming languages feature special syntax for declaring a global variable, for example, Python lets us use the <code>global</code> keyword:
<pre><code class="hljs">global a_variable = 5
</code></pre>
C creates globals by simply declaring a variable outside a function.
<pre><code class="hljs">int aVariable = 3;

int someFunction() {
 print(aVariable);
}
</code></pre>
Regardless of the syntax for creating the global variable, they work more or less the same way. They allow you to access and modify the value from inside any other class or function. This can cause problems if you try to re-use the name in another scope. For example:
<pre><code class="hljs">int aVariable = 3;

int someFunction() {
 int aVariable = 7;
 print(aVariable);
}
</code></pre>
Depending on the language, this is generally handled in one of three ways:
<ul>
<li>Throw an error for declaring a variable that already exists.</li>
<li>Assume the print statement references the local variable.</li>
<li>Assume the print statement references the local variable unless special syntax is used to reference the global.</li>
</ul>
The third method is how Java handles instance variables when a method parameter uses the same name. Picture a class with a variable declared as <code>private int number</code>. To modify the value of <code>number</code> later on, you could create a function:
<pre><code class="hljs">public int setNumber(int number) {
 this.number = number;
}
</code></pre>
The <code>this</code> keyword shows that you want the <code>number</code> from the class, not from the method parameters.
<h2 id="whydoesntjavauseglobalvariables">Why Doesn't Java use Global Variables?</h2>
The short answer to this question is: intentional design. Java was created as a purely object-oriented programming language, which is why everything you create is wrapped in a class.
By being purely object-oriented, developers are encouraged to keep related variables and functions together, making the program as a whole more organized. This can also help with identifying the purpose of a poorly documented variable. For example:
<pre><code class="hljs">class GridCoordinate {
 int x;
 int y;
}
</code></pre>
Without the knowledge that these variables were part of a <code>GridCoordinate</code> class, it would be near impossible to identify them. With the context of the class name, we can infer they are the horizontal and vertical positions of a given point on a grid.
Now picture you're working as part of a fully remote team with members around the globe. You and a coworker on another continent are both working on the same file when you both come across this:
<pre><code class="hljs">global ver = 2.55
</code></pre>
You make the assumption that the variable represents a version number. Your coworker thinks it might have something to do with a vertical axis. You both make changes to different functions based on your assumptions, modifying and referencing the value as you see fit.
This is the type of situation that Java tries to avoid by not having global variables. Using global variables in a large project can lead to unintended and unexpected behavior as variables are declared and modified in different sections of the code.
<h2 id="howtoemulateaglobalvariableinjava">How to Emulate a Global Variable in Java?</h2>
Though there are some drawbacks to global variable use, there are times that you may want a variable to be accessed in many places, but you may feel that it doesn't warrant creating a dedicated wrapper class.
For example, you may want to reference your database connection in multiple classes, but haven't declared a <code>DatabaseConnection</code> class to handle all of your database functionality. You may also just prefer to just use the built-in methods from the database library of your choice without a wrapper to handle transactions.
Usually, you can create a <code>Constants</code> or a <code>Reference</code> class, where you keep various &quot;global&quot; values stored if they're used commonly in other parts of the application. A single variable doesn't necessarily warrant an entire class, so you can encompass many of them in a single <code>Reference</code> or <code>Constants</code> class:
<pre><code class="hljs">public class Reference {
 public static final double VERSION_NUMBER;
 public static final String DATABASE_URL;
 public static final Database DATABASE;
}
</code></pre>
These variables can then be accessed elsewhere by referencing the class:
<pre><code class="hljs">public int someMethod() {
 System.out.println(Reference.VERSION_NUMBER);
}
</code></pre>
Having the <code>Reference</code> class makes it easy to know where to look for comments explaining the purpose of the variable. Had the variables above been created as true global variables, it's likely they would have been created in different files, making it harder to find the author's intended purpose.
A better way to use the <code>Reference</code> class would be to treat all variables as private, and use getter methods to control all access to the values. It is also wise to use constants instead of variables for data that should not change while the program is running. For example:
<pre><code class="hljs">private static final String DATABASE_URL = &quot;https://databaseurl.db/database&quot;;
private static final Database DATABASE = Database.connect(databaseURL);

public static Database getDatabase() { return DATABASE; }
public static String getUrl() { return DATABASE_URL}
</code></pre>
In this example, the database URL and database connection cannot be modified anywhere else in the code, but the database connection can be referenced as needed for transactions.
While this isn't quite as clean syntactically as defining a global variable, it can provide the same level of freedom.
Another common usage would be to define some constants in an application that has immutable values that you use often. For example, if you're training a Neural Network or running Genetic Algorithms, you'll have various values used all over the place:
<pre><code class="hljs">public static final int GENERATION_SIZE;
public static final int GENOME_SIZE;
public static final int REPRODUCTION_SIZE;
public static final int MAX_ITERATIONS;
</code></pre>
Then, you'd access these through their public class, such as:
<pre><code class="hljs">for(int i = 0; i &lt; Constants.MAX_ITERATIONS; i++) {
 // ...
}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Global variables are often seen as a divisive topic, with many developers saying they should never be used. These developers generally argue that global variables make the code harder to maintain. There are, however, some instances where global-like variables are useful so long as they are well organized and clearly identified.
Ultimately, the decision to use them falls on you or a senior member of the development team.
In this article, we've gone over how to emulate global variables in Java.

Guest Contributor

In this tutorial, we've gone over what global variables are and examples of how you can emulate global variables and create constants in Java applications.

Using Global Variables/Constants in Java

<h2 id="introduction">Introduction</h2>
Seaborn is one of the most widely used data visualization libraries in Python, as an extension to Matplotlib. It offers a simple, intuitive, yet highly customizable API for data visualization.
In this tutorial, we'll take a look at how to plot a Distribution Plot in Seaborn. We'll cover how to plot a Distribution Plot with Seaborn, how to change a Distribution Plot's bin sizes, as well as plot Kernel Density Estimation plots on top of them and show distribution data instead of count data.
<h2 id="importdata">Import Data</h2>
We'll be using the <a rel="noopener nofollow" target="_blank" href="https://www.kaggle.com/shivamb/netflix-shows">Netflix Shows</a> dataset and visualizing the distributions from there.
Let's import Pandas and load in the dataset:
<pre><code class="hljs">import pandas as pd

df = pd.read_csv(&#x27;netflix_titles.csv&#x27;)
</code></pre>
<h2 id="howtoplotadistributionplotwithseaborn">How to Plot a Distribution Plot with Seaborn?</h2>
Seaborn has different types of distribution plots that you might want to use.
These plot types are: KDE Plots (<code>kdeplot()</code>), and Histogram Plots (<code>histplot()</code>). Both of these can be achieved through the generic <code>displot()</code> function, or through their respective functions.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Since Seaborn 0.11, <code>distplot()</code> has become <code>displot()</code>. If you're using an older version, you'll have to use the older function as well.

 </div>
 </div>
 </div>
 Let's start plotting.
<h2 id="plothistogramdistributionplotdisplotwithseaborn">Plot Histogram/Distribution Plot (displot) with Seaborn</h2>
Let's go ahead and import the required modules and generate a Histogram/Distribution Plot.
We'll visualize the distribution of the <code>release_year</code> feature, to see when Netflix was the most active with new additions:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import seaborn as sns

# Load the data
df = pd.read_csv(&#x27;netflix_titles.csv&#x27;)
# Extract feature we&#x27;re interested in
data = df[&#x27;release_year&#x27;]

# Generate histogram/distribution plot
sns.displot(data)

plt.show()
</code></pre>
Now, if we run the code, we'll be greeted with a histogram plot, showing the count of the occurrences of these <code>release_year</code> values:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-distribution-histogram-plot-tutorial-and-examples-1.png" alt="histogram plot seaborn">
<h2 id="plotdistributionplotwithdensityinformationwithseaborn">Plot Distribution Plot with Density Information with Seaborn</h2>
Now, as with Matplotlib, the default histogram approach is to count the number of occurrences. Instead, you can visualize the distribution of each of these release_years in percentages.
Let's modify the <code>displot()</code> call to change that:
<pre><code class="hljs"># Extract feature we&#x27;re interested in
data = df[&#x27;release_year&#x27;]

# Generate histogram/distribution plot
sns.displot(data, stat = &#x27;density&#x27;)

plt.show()
</code></pre>
The only thing we need to change is to provide the <code>stat</code> argument, and let it know that we'd like to see the density, instead of the <code>'count'</code>.
Now, instead of the count we've seen before, we'll be presented with the density of entries:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-distribution-histogram-plot-tutorial-and-examples-2.png" alt="histogram density information seaborn">
<h2 id="changedistributionplotbinsizewithseaborn">Change Distribution Plot Bin Size with Seaborn</h2>
Sometimes, the automatic bin sizes don't work very well for us. They're too big or too small. By default, the size is chosen based on the observed variance in the data, but this sometimes can't be different from what we'd like to bring to light.
In our plot, they're a bit too small and awkwardly placed with gaps between them. We can change the bin size either by setting the <code>binwidth</code> for each bin, or by setting the number of <code>bins</code>:
<pre><code class="hljs">data = df[&#x27;release_year&#x27;]

sns.displot(data, binwidth = 3)

plt.show()
</code></pre>
This will make each bin encompass data in ranges of 3 years:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-distribution-histogram-plot-tutorial-and-examples-3.png" alt="change histogram bin sizes seaborn">
Or, we can set a fixed number of <code>bins</code>:
<pre><code class="hljs">data = df[&#x27;release_year&#x27;]

sns.displot(data, bins = 30)

plt.show()
</code></pre>
Now, the data will be packed into 30 bins and depending on the range of your dataset, this will either be a lot of bins, or a really small amount:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-distribution-histogram-plot-tutorial-and-examples-4.png" alt="histogram bin number seaborn">
Another great way to get rid of the awkward gaps is to set the <code>discrete</code> argument to <code>True</code>:
<pre><code class="hljs">data = df[&#x27;release_year&#x27;]

sns.displot(data, discrete=True)

plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-distribution-histogram-plot-tutorial-and-examples-5.png" alt="histogram discrete data seaborn">
<h2 id="plotdistributionplotwithkde">Plot Distribution Plot with KDE</h2>
A common plot to plot alongside a Histogram is the Kernel Density Estimation plot. They're smooth and you don't lose any value by snatching ranges of values into bins. You can set a larger bin value, overlay a KDE plot over the Histogram and have all the relevant information on screen.
Thankfully, since this was a really common thing to do, Seaborn lets us plot a KDE plot simply by setting the <code>kde</code> argument to <code>True</code>:
<pre><code class="hljs">data = df[&#x27;release_year&#x27;]

sns.displot(data, discrete = True, kde = True)

plt.show()
</code></pre>
This now results in:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-distribution-histogram-plot-tutorial-and-examples-6.png" alt="plot histogram with kde seaborn">
<h2 id="plotjointdistributionplotwithseaborn">Plot Joint Distribution Plot with Seaborn</h2>
Sometimes, you might want to visualize multiple features against each other, and their distributions. For example, we might want to visualize the distribution of the show ratings, as well as the year of their addition. If we were looking to see if Netflix started adding more kid-friendly content over the years, this would be a great pairing for a Joint Plot.
Let's make a <code>jointplot()</code>:
<pre><code class="hljs">df = pd.read_csv(&#x27;netflix_titles.csv&#x27;)
df.dropna(inplace=True)

sns.jointplot(x = &quot;rating&quot;, y = &quot;release_year&quot;, data = df)

plt.show()
</code></pre>
We've dropped null values here since Seaborn will have trouble converting them to usable values.
Here, we've made a Histogram plot for the rating feature, as well as a Histogram plot for the release_year feature:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-distribution-histogram-plot-tutorial-and-examples-7.png" alt="joint histogram plot seaborn">
We can see that most of the added entries are TV-MA, however, there's also a lot of TV-14 entries so there's a nice selection of shows for the entire family.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to plot a distribution plot using Seaborn and Python.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Become dangerous with Data Visualization
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with 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 how to plot a histogram/distribution plot in Python using Seaborn. We'll cover histogram plots, histogram bin sizes, as well as density plots and customization.

Seaborn Distribution/Histogram Plot - Tutorial and Examples

<h2 id="introduction">Introduction</h2>
In this article, we'll take a look at how to convert Bytes to a String in Python. By the end of this article you will have a clear idea of what these types are and how to effectively handle data using them.
Depending on the version of Python you're using, this task will differ. Although Python 2 has reached its end of life, many projects still use it, so we'll include both the Python 2 and Python 3 approaches.
<h2 id="convertbytestostringinpython3">Convert Bytes to String in Python 3</h2>
Since Python 3, the old ASCII way of doing things had to go, and Python became completely Unicode.
This means that we lost the explicit unicode type: <code>u&quot;string&quot;</code> - every string is a <code>u&quot;string&quot;</code>!
To differentiate these strings from good old bytestrings, we're introduced to a new specifier for them - the <code>b&quot;string&quot;</code>.
<blockquote>
This was added in Python 2.6, but it served no real purpose other than to prepare for Python 3 as all strings were bytestrings in 2.6.
</blockquote>
Bytestrings in Python 3 are officially called <code>bytes</code>, an immutable sequence of integers in the range 0 &lt;= x &lt; 256. Another <code>bytes</code>-like object added in 2.6 is the <code>bytearray</code> - similar to <code>bytes</code>, but mutable.
<h3 id="convertbytestostringwithdecode">Convert Bytes to String with decode()</h3>
Let's take a look at how we can convert bytes to a String, using the built-in <code>decode()</code> method for the <code>bytes</code> class:
<pre><code class="hljs">&gt;&gt;&gt; b = b&quot;Lets grab a \xf0\x9f\x8d\x95!&quot;
# Let&#x27;s check the type
&gt;&gt;&gt; type(b)
&lt;class &#x27;bytes&#x27;&gt;

# Now, let&#x27;s decode/convert them into a string
&gt;&gt;&gt; s = b.decode(&#x27;UTF-8&#x27;)
&gt;&gt;&gt; s
&quot;Let&#x27;s grab a 🍕!&quot;
</code></pre>
Passing the encoding format, we've decoded the <code>bytes</code> object into a string and printed it.
<h3 id="convertbytestostringwithcodecs">Convert Bytes to String with codecs</h3>
Alternatively, we can use the built-in <code>codecs</code> module for this purpose as well:
<pre><code class="hljs">&gt;&gt;&gt; import codecs
&gt;&gt;&gt; b = b&#x27;Lets grab a \xf0\x9f\x8d\x95!&#x27;

&gt;&gt;&gt; codecs.decode(b, &#x27;UTF-8&#x27;)
&quot;Let&#x27;s grab a 🍕!&quot;
</code></pre>
You don't really need to pass in the encoding parameter, though, it is advised to pass it in:
<pre><code class="hljs">&gt;&gt;&gt; codecs.decode(b)
&quot;Let&#x27;s grab a 🍕!&quot;
</code></pre>
<h3 id="convertbytestostringwithstr">Convert Bytes to String with str()</h3>
Finally, you can use the <code>str()</code> function, which accepts various values and converts them into strings:
<pre><code class="hljs">&gt;&gt;&gt; b = b&#x27;Lets grab a \xf0\x9f\x8d\x95!&#x27;
&gt;&gt;&gt; str(b, &#x27;UTF-8&#x27;)
&quot;Let&#x27;s grab a 🍕!&quot;
</code></pre>
Make sure to provide the encoding argument to <code>str()</code> though, otherwise you might get some unexpected results:
<pre><code class="hljs">&gt;&gt;&gt; str(b)
b&#x27;Lets grab a \xf0\x9f\x8d\x95!&#x27;
</code></pre>
This brings us to encodings once again. If you specify the wrong encoding, the best case is your program crashing because it can't decode the data. For example, if we tried using the <code>str()</code> function with <code>UTF-16</code>, we'd be greeted with:
<pre><code class="hljs">&gt;&gt;&gt; str(b, &#x27;UTF-16&#x27;)
&#x27;敌❴\u2073牧扡愠\uf020趟↕&#x27;
</code></pre>
This is even more important given that Python 3 likes to assume Unicode - so if you are working with files or data sources that use an obscure encoding, make sure to pay extra attention.
<h2 id="convertbytestostringinpython2">Convert Bytes to String in Python 2</h2>
In Python 2, a bundle of bytes and a string are practically the same thing - strings are objects consisting of 1-byte long characters, meaning that each character can store 256 values. That's why they are sometimes called bytestrings.
This is great when working with byte data - we just load it into a variable and we are ready to print:
<pre><code class="hljs">&gt;&gt;&gt; s = &quot;Hello world!&quot;

&gt;&gt;&gt; s
&#x27;Hello world!&#x27;

&gt;&gt;&gt; len(s)
12
</code></pre>
Using Unicode characters in bytestrings does change this behavior a bit though:
<pre><code class="hljs">&gt;&gt;&gt; s = &quot;Let&#x27;s grab a 🍕!&quot;

&gt;&gt;&gt; s
&#x27;Lets grab a \xf0\x9f\x8d\x95!&#x27;
# Where has the pizza gone to?

&gt;&gt;&gt; len(s)
17
# Shouldn&#x27;t that be 15?
</code></pre>
<h3 id="convertbytestounicodepython2">Convert Bytes to Unicode (Python 2)</h3>
Here, we'll have to use Python 2's <code>Unicode</code> type, which is assumed and automatically used in Python 3. This stores strings as a series of code points, rather than bytes.
The <code>\xf0\x9f\x8d\x95</code> represents bytes as two-digit hex numbers as Python doesn't know how to represent them as ASCII characters:
<pre><code class="hljs">&gt;&gt;&gt; u = u&quot;Let&#x27;s grab a 🍕!&quot;
u&quot;Let&#x27;s grab a \U0001f355!&quot;&quot;

&gt;&gt;&gt; u
&quot;Let&#x27;s grab a 🍕!&quot;
# Yum.

&gt;&gt;&gt; len(u)
15
</code></pre>
As you can see above, the Unicode string contains <code>\U0001f355</code> - a Unicode escaped character which our terminal now knows how to print out as a slice of pizza! Setting this was as easy as using the <code>u</code> specifier before the value of the bytestring.
<blockquote>
So, how do I switch between the two?
</blockquote>
You can get the Unicode string by decoding your bytestring. This can be done by constructing a Unicode object, providing the bytestring and a string containing the encoding name as arguments or by calling <code>.decode(encoding)</code> on a bytestring.
<h3 id="convertbytestostringusingdecodepython2">Convert Bytes to String Using decode() (Python 2)</h3>
You can also use the <code>codecs.encode(s, encoding)</code> from the <code>codecs</code> module.
<pre><code class="hljs">&gt;&gt;&gt; s = &quot;Let&#x27;s grab a \xf0\x9f\x8d\x95!&quot;
&gt;&gt;&gt; u = unicode(s, &#x27;UTF-8&#x27;)

&gt;&gt;&gt; u
&quot;Let&#x27;s grab a 🍕!&quot;

&gt;&gt;&gt; s.decode(&#x27;UTF-8&#x27;)
&quot;Let&#x27;s grab a 🍕!&quot;
</code></pre>
<h3 id="convertbytestostringusingcodecspython2">Convert Bytes to String Using codecs (Python 2)</h3>
Or, using the <code>codecs</code> module:
<pre><code class="hljs">import codecs

&gt;&gt;&gt; codecs.decode(s, &#x27;UTF-8&#x27;)
&quot;Let&#x27;s grab a 🍕!&quot;
</code></pre>
<h2 id="bemindfulofyourencoding">Be Mindful of your Encoding</h2>
A word of caution here - bytes can be interpreted differently in different encodings. With around 80 different encodings available out of the box, it might not be easy to know if you've got the right one!
<pre><code class="hljs">s = &#x27;\xf8\xe7&#x27;

# This one will let us know we used the wrong encoding

&gt;&gt;&gt; s.decode(&#x27;UTF-8&#x27;)
UnicodeDecodeError: &#x27;utf8&#x27; codec can&#x27;t decode byte 0xf8 in position 0:
invalid start byte

# These two overlaps and this is a valid string in both

&gt;&gt;&gt; s.decode(&#x27;latin1&#x27;)
øç

s.decode(&#x27;iso8859_5&#x27;)
јч
</code></pre>
The original message was either <code>øç</code> or <code>јч</code>, and both appear to be valid conversions.
<h2 id="conclusion">Conclusion</h2>
As programmers, there are some things we must constantly think about and actively prepare for in order to avoid pitfalls. This holds especially true on the lower levels, where we seldom go when we use a high-level language like Python as our daily driver.
Things like charsets, encodings and binary are there to remind us that our job is to code - to encode our thoughts into working solutions. Thankfully, a lot of this thinking becomes part of our routine after a few rounds at the keyboard.
In this article, we've gone over how to convert bytes to Strings in Python.

In this tutorial, we'll go over examples of how to convert bytes to a string in Python 2 and 3. We'll use the decode() function, str() function as well as the codecs module.

Convert Bytes to String in Python

<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 tutorial, we'll take a look at how to plot a histogram plot in Matplotlib. Histogram plots are a great way to visualize distributions of data - In a histogram, each bar groups numbers into ranges. Taller bars show that more data falls in that range.
<blockquote>
A histogram displays the shape and spread of continuous sample data.
</blockquote>
<h2 id="importdata">Import Data</h2>
We'll be using the <a rel="noopener nofollow" target="_blank" href="https://www.kaggle.com/shivamb/netflix-shows">Netflix Shows</a> dataset and visualizing the distributions from there.
Let's import Pandas and load in the dataset:
<pre><code class="hljs">import pandas as pd

df = pd.read_csv(&#x27;netflix_titles.csv&#x27;)
</code></pre>
<h2 id="plotahistogramplotinmatplotlib">Plot a Histogram Plot in Matplotlib</h2>
Now, with the dataset loaded in, let's import Matplotlib's PyPlot module and visualize the distribution of <code>release_year</code>s of the shows that are live on Netflix:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd

df = pd.read_csv(&#x27;netflix_titles.csv&#x27;)
plt.hist(df[&#x27;release_year&#x27;])

plt.show()
</code></pre>
Here, we've got a minimum-setup scenario. We load the data into a DataFrame (<code>df</code>), then, we use the PyPlot instance and call the <code>hist()</code> function to plot a histogram for the <code>release_year</code> feature. By default, this'll count the number of occurrences of these years, populate bars in ranges and plot the histogram.
Running this code results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-histogram-plot-tutorial-and-examples-1.png" alt="matplotlib simple histogram plot tutorial">
Here, the movie bins (ranges) are set to 10 years. Each bar here includes all shows/movies in batches of 10 years. For example, we can see that around ~750 shows were released between 2000. and 2010. At the same time, ~5000 were released between 2010. and 2020.
These are pretty big ranges for the movie industry, it makes more sense to visualize this for ranges smaller than 10 years.
<h2 id="changehistogrambinsizeinmatplotlib">Change Histogram Bin Size in Matplotlib</h2>
Say, let's visualize a histogram (distribution) plot in batches of 1 year, since this is a much more realistic time-frame for movie and show releases.
We'll import <code>numpy</code>, as it'll help us calculate the size of the bins:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

df = pd.read_csv(&#x27;netflix_titles.csv&#x27;)
data = df[&#x27;release_year&#x27;]

plt.hist(data, bins=np.arange(min(data), max(data) + 1, 1))

plt.show()
</code></pre>
This time around, we've extracted the DataFrame column into a <code>data</code> variable, just to make it a bit easier to work with.
We've passed the <code>data</code> to the <code>hist()</code> function, and set the <code>bins</code> argument. It accepts a list, which you can set manually, if you'd like, especially if you want a non-uniform bin distribution.
Since we'd like to pool these entries each in the same time-span (1 year), we'll create a NumPy array, that starts with the lowest value (<code>min(data)</code>), ends at the highest value (<code>max(data)</code>) and goes in increments of <code>1</code>.
This time around, running this code results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-histogram-plot-tutorial-and-examples-2.png" alt="change histogram bin size in matplotlib">
Instead of a list, you can give a single <code>bins</code> value. This will be the total number of <code>bins</code> in the plot. Using <code>1</code> will result in 1 bar for the entire plot.
Say, we want to have 20 bins, we'd use:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

df = pd.read_csv(&#x27;netflix_titles.csv&#x27;)
data = df[&#x27;release_year&#x27;]

plt.hist(data, bins=20)

plt.show()
</code></pre>
This results in 20 equal bins, with data within those bins pooled and visualized in their respective bars:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-histogram-plot-tutorial-and-examples-3.png" alt="change histogram bin size uniformly in matplotlib">
This results in 5-year intervals, considering we've got ~100 years worth of data. Splitting it up in 20 bins means that each will include 5 years worth of data.
<h2 id="plothistogramwithdensity">Plot Histogram with Density</h2>
Sometimes, instead of the count of the features, we'd want to check what the density of each bar/bin is. That is, how common it is to see a range within a given dataset. Since we're working with 1-year intervals, this'll result in the probability that a movie/show was released in that year.
To do this, we can simply set the <code>density</code> argument to <code>True</code>:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

df = pd.read_csv(&#x27;netflix_titles.csv&#x27;)
data = df[&#x27;release_year&#x27;]
bins = np.arange(min(data), max(data) + 1, 1)

plt.hist(data, bins=bins, density=True)
plt.ylabel(&#x27;Density&#x27;)
plt.xlabel(&#x27;Year&#x27;)

plt.show()
</code></pre>
Now, instead of the count we've seen before, we'll be presented with the density of entries:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-histogram-plot-tutorial-and-examples-4.png" alt="histogram plot with density matplotlib">
We can see that ~18% of the entries were released in 2018, followed by ~14% in 2019.
<h2 id="customizinghistogramplotsinmatplotlib">Customizing Histogram Plots in Matplotlib</h2>
Other than these settings, there's a plethora of various arguments you can set to customize and change the way your plot looks like. Let's change a few of the common options people like to fiddle around with to change plots to their tastes:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

df = pd.read_csv(&#x27;netflix_titles.csv&#x27;)
data = df[&#x27;release_year&#x27;]
bins = np.arange(min(data), max(data) + 1, 1)

plt.hist(data, bins=bins, density=True, histtype=&#x27;step&#x27;, alpha=0.5, align=&#x27;right&#x27;, orientation=&#x27;horizontal&#x27;, log=True)

plt.show()
</code></pre>
Here, we've set various arguments:
<ul>
<li><code>bins</code> - Number of bins in the plot</li>
<li><code>density</code> - Whether PyPlot uses count or density to populate the plot</li>
<li><code>histtype</code> - The type of histogram plot (default is <code>bar</code>, though other values such as <code>step</code> or <code>stepfilled</code> are available)</li>
<li><code>alpha</code> - The alpha/transparency of the lines</li>
<li><code>align</code> - To which side of the bins the bars are aligned, default is <code>mid</code></li>
<li><code>orientation</code> - Horizontal/Vertical orientation, default is <code>vertical</code></li>
<li><code>log</code> - Whether the plot should be put on a logarithmic scale or not</li>
</ul>
This now results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-histogram-plot-tutorial-and-examples-5.png" alt="customize matplotlib histogram">
Since we've put the <code>align</code> to <code>right</code>, we can see that the bar is offset a bit, to the vertical right of the 2020 bin.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to plot a histogram 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 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 how to plot a histogram plot in Python using Matplotlib. We'll cover histogram plots, histogram bin sizes, as well as density plots and customization.

Matplotlib Histogram Plot - Tutorial and Examples

<h2 id="introduction">Introduction</h2>
Lists are one of the four most commonly used data structures provided by Python. Its functionality, extensibility, and ease of use make it useful for implementing various types of functionalities.
Python lists have a few interesting characteristics:
<ol>
<li>Mutability - meaning it can change, which means it allows us to easily add and delete entries from it. This is the main difference between Python lists and tuples</li>
<li>Iterability - which means we can iterate through it (go through all elements in the list in-order)</li>
</ol>
The main attribute that will be focusing on is Iterability. An important part when dealing with an iterable object, in this case a list, is checking if there's anything to iterate through. If not handled properly, this can lead to a lot of unwanted errors.
Python provides various ways to check if our list is empty or not, some implicit and some explicit, and in this article, we'll go over how to check if a Python list is empty.
<ul>
<li><a href="#usinglenfunction">Using the <code>len()</code> Function</a></li>
<li><a href="#usinglenwithcomparisonoperator">Using <code>len()</code> With a Comparison Operator</a></li>
<li><a href="#comparisonwithemptylist">Comparison with Empty List</a></li>
<li><a href="#pep8recommendedstyle">Pep-8 Recommended Style</a> (Most Popular and Advised)</li>
<li><a href="#usingboolfunction">Using the <code>bool()</code> Function</a></li>
</ul>
<h2 id="usinglenfunction">Using <code>len()</code> Function</h2>
One of the techniques is to use the <code>len()</code> function to check if our list is empty or not:
<pre><code class="hljs">py_list = []

&quot;&quot;&quot;
Here len() returns 0, which is 
implicitly converted to false
&quot;&quot;&quot;

if len(py_list):
 print(&#x27;The list is not empty&#x27;)
else:
 print(&#x27;T list is empty&#x27;)
</code></pre>
Output
<pre><code class="hljs">List is empty
</code></pre>
When <code>len(py_list)</code> executes it produces zero, which is then implicitly cast to the boolean value of <code>False</code>. Thus in case of an empty list the program will be redirected to the else block.
Although this method looks simple, it's not that intuitive for beginners.
<h2 id="usinglenwithcomparisonoperator">Using len() With Comparison Operator</h2>
This technique is similar to the one above but it is more explicit and easy to understand. That's why those who are new to python or coding itself usually consider it more intuitive:
<pre><code class="hljs">if len(py_list) == 0:
 print(&#x27;List is empty&#x27;)
else:
 print(&#x27;List not empty&#x27;)
</code></pre>
In the code above, <code>len(py_list) == 0</code> will be true if the list is empty and will will be redirected to the else block. This also allows you to set other values as well, rather than relying on <code>0</code> being converted as <code>False</code>. All other positive values are converted to <code>True</code>.
<h2 id="comparisonwithemptylist">Comparison With Empty List</h2>
This method is also very simple and works well for beginners as it involves comparing with an empty list:
<pre><code class="hljs">if py_list == []:
 print(&#x27;List is empty&#x27;)
else:
 print(&#x27;List is not empty&#x27;)
</code></pre>
Here again, we are using the comparison operation to compare one list with another - an empty one, and if both are empty the <code>if</code> block will execute.
<h2 id="pep8recommendedstyle">Pep-8 Recommended Style</h2>
<pre><code class="hljs">#PEP-8 recommended style

if py_list:
 print(&#x27;List is not empty&#x27;)
if not py_list:
 print(&#x27;List empty&#x27;)
</code></pre>
For this, let's take a look at <a rel="nofollow noopener" target="_blank" href="https://docs.python.org/3/library/stdtypes.html#truth-value-testing">Truth Value Testing</a>. The official docs state that:
<blockquote>
Here are most of the built-in objects considered false:
<ul>
<li>constants defined to be false: None and False.</li>
<li>zero of any numeric type: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)</li>
<li>empty sequences and collections: '', (), [], {}, set(), range(0)</li>
</ul>
</blockquote>
As an empty list is in fact just an empty collection, it will be converted to a boolean value of <code>False</code>. Therefore, if <code>py_list</code> is empty, it will be converted to <code>False</code>.
The second statement is pretty similar, except <code>not</code> will invert a false condition to a true one. This approach is very similar to the <code>if(len(list))</code> approach.
This is the preferred approach as it's the cleanest and shortest solution there is.
<h2 id="usingboolfunction">Using bool() Function</h2>
We can also use the <code>bool()</code> function to verify a list is empty:
<pre><code class="hljs">#As truth value testing says [] braces denotes false

if bool(py_list):
 print(&#x27;List is not empty&#x27;)
else:
 print(&#x27;List is empty&#x27;)
</code></pre>
This is basically a manually implemented truth value test. So if the list is not empty the function will return <code>True</code> and if block will be executed.
This approach is less common as we can achieve the desired results even without using <code>bool()</code>, but it's not a bad thing to know how Python works under the hood.
<h2 id="conclusion">Conclusion</h2>
This article was all about ways to check if our python list is empty or not. We started by exploring different techniques and finally looking into some parameters that we can use to make our judgment regarding which technique may work for us.
I can't say that this is the end as new Python updates may give rise to new and more improved coding styles. So it's better to keep exploring and keep learning.

In this tutorial, we'll go over examples on How to Check if List is Empty in Python. We'll be using the len() function, Pep-8 Recommended Style, as well as the bool() function.

How to Check if List is Empty in Python

<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 marker size in a Matplotlib scatter plot.
<h2 id="importdata">Import Data</h2>
We'll use the <a rel="nofollow noopener" target="_blank" href="https://www.kaggle.com/unsdsn/world-happiness">World Happiness</a> dataset, and compare the Happiness Score against varying features to see what influences perceived happiness in the world:
<pre><code class="hljs">import pandas as pd

df = pd.read_csv(&#x27;worldHappiness2019.csv&#x27;)
</code></pre>
Then, we can easily manipulate the size of the markers used to represent entries in this dataset.
<h2 id="changemarkersizeinmatplotlibscatterplot">Change Marker Size in Matplotlib Scatter Plot</h2>
Let's start off by plotting the generosity score against the GDP per capita:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd

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

fig, ax = plt.subplots(figsize=(10, 6))
ax.scatter(x = df[&#x27;GDP per capita&#x27;], y = df[&#x27;Generosity&#x27;])
plt.xlabel(&quot;GDP per Capita&quot;)
plt.ylabel(&quot;Generosity Score&quot;)

plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-change-scatter-plot-marker-size-1.png" alt="matplotlib scatter plot">
Now, let's say we'd like to increase the size of each marker, based on the perceived happiness of the inhabitants of that country. The happiness score is a list, coming straight from the <code>df</code>, so this can work with other lists as well.
To change the size of the markers, we use the <code>s</code> argument, for the <code>scatter()</code> function. This will be the <code>markersize</code> argument for the <code>plot()</code> function:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd

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

fig, ax = plt.subplots(figsize=(10, 6))
ax.scatter(x = df[&#x27;GDP per capita&#x27;], y = df[&#x27;Generosity&#x27;], s = df[&#x27;Score&#x27;]*25)
plt.xlabel(&quot;GDP per Capita&quot;)
plt.ylabel(&quot;Generosity Score&quot;)

plt.show()
</code></pre>
We've also multiplied the value of each element in the list by an arbitrary number of 25, because they're ranked from <code>0..1</code>. This will produce really small markers if we use them in their original values.
This now results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-change-scatter-plot-marker-size-2.png" alt="matplotlib change scatter plot marker size">
Or better yet, instead of crudely multiplying everything by 25, since the values are similar anyway, we can do something like this:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd

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

size = df[&#x27;Score&#x27;].to_numpy()
s = [3*s**2 for s in size]

fig, ax = plt.subplots(figsize=(10, 6))
ax.scatter(x = df[&#x27;GDP per capita&#x27;], y = df[&#x27;Generosity&#x27;], s = s)
plt.xlabel(&quot;GDP per Capita&quot;)
plt.ylabel(&quot;Generosity Score&quot;)

plt.show()
</code></pre>
It's important to have the <code>s</code> list the same length as <code>x</code> and <code>y</code>, as each value from <code>s</code> now gets applied to them. If the list is shorter or longer, the code will break.
Here, we've extracted the values from the <code>Score</code> column, scaled them and applied the size back to the scatter plot:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-change-scatter-plot-marker-size-4.png" alt="scaled marker size scatter plot matplotlib">
<h2 id="setglobalmarkersizeinmatplotlibscatterplot">Set Global Marker Size in Matplotlib Scatter Plot</h2>
If you'd like to detach the marker size from some variable, and would just like to set a standard, global size of markers in the scatter plot, you can simply pass in a single value for <code>s</code>:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd

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

fig, ax = plt.subplots(figsize=(10, 6))
ax.scatter(x = df[&#x27;GDP per capita&#x27;], y = df[&#x27;Generosity&#x27;], s = 100)
plt.xlabel(&quot;GDP per Capita&quot;)
plt.ylabel(&quot;Generosity Score&quot;)

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

In this tutorial, we'll go over examples of how to change the marker size of an individual, as well as all markers in a Matplotlib Scatter Plot using Python.