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

David Landup

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.

Matplotlib: Change Scatter Plot Marker Size

Rayven Yor Esplanada

In this tutorial, we'll build a demo Spring Boot REST API application, with CRUD functionality. We'll cover database setup, the domain model, persistence layer as well as the business layer.

Build a Spring Boot REST API with Java - Full Guide

<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 rotate tick text/labels in a Matplotlib plot.
<h2 id="creatingaplot">Creating a Plot</h2>
Let's create a simple plot first:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

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

plt.plot(x, y)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/%7Frotate-axis-labels-in-matplotlib-1.png" alt="simple matplotlib plot">
<h2 id="rotatexaxisticklabelsinmatplotlib">Rotate X-Axis Tick Labels in Matplotlib</h2>
Now, let's take a look at how we can rotate the X-Axis tick labels here. There are two ways to go about it - change it on the Figure-level using <code>plt.xticks()</code> or change it on an Axes-level by using <code>tick.set_rotation()</code> individually, or even by using <code>ax.set_xticklabels()</code> and <code>ax.xtick_params()</code>.
Let's start off with the first option:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

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

plt.plot(x, y)
plt.xticks(rotation = 45) # Rotates X-Axis Ticks by 45-degrees
plt.show()
</code></pre>
Here, we've set the <code>rotation</code> of <code>xticks</code> to 45, signifying a 45-degree tilt, counterclockwise:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-2.png" alt="rotate x-axis label with xticks">

 <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 function, like all others here, should be called after <code>plt.plot()</code>, lest the ticks end up being potentially cropped or misplaced.

 </div>
 </div>
 </div>
 Another option would be to get the current <code>Axes</code> object and call <code>ax.set_xticklabels()</code> on it. Here we can set the labels, as well as their rotation:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

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

plt.plot(x, y)

ax = plt.gca()
plt.draw()

ax.set_xticklabels(ax.get_xticks(), rotation = 45)

plt.show()
</code></pre>

 <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: For this approach to work, you'll need to call <code>plt.draw()</code> before accessing or setting the X tick labels. This is because the labels are populated after the plot is drawn, otherwise, they'll return empty text values.

 </div>
 </div>
 </div>
 <img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-3.png" alt="rotate x axis labels with xticklabels">
Alternatively, we could've iterated over the <code>tick</code>s in the <code>ax.get_xticklabels()</code> list. Then, we can call <code>tick.set_rotation()</code> on each of them:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

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

plt.plot(x, y)

ax = plt.gca()
plt.draw()

for tick in ax.get_xticklabels():
 tick.set_rotation(45)
plt.show()
</code></pre>
This also results in:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-4.png" alt="rotate x axis labels with set_rotation">
And finally, you can use the <code>ax.tick_params()</code> function and set the label rotation there:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

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

plt.plot(x, y)

ax = plt.gca()
ax.tick_params(axis=&#x27;x&#x27;, labelrotation = 45)
plt.show()
</code></pre>
This also results in:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-4.png" alt="rotate x axis labels with tick_params">
<h2 id="rotateyaxisticklabelsinmatplotlib">Rotate Y-Axis Tick Labels in Matplotlib</h2>
The exact same steps can be applied for the Y-Axis tick labels.
Firstly, you can change it on the Figure-level with <code>plt.yticks()</code>, or on the Axes-level by using <code>tick.set_rotation()</code> or by manipulating the <code>ax.set_yticklabels()</code> and <code>ax.tick_params()</code>.
Let's start off with the first option:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

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

plt.plot(x, y)
plt.yticks(rotation = 45)
plt.show()
</code></pre>
Same as last time, this sets the <code>rotation</code> of <code>yticks</code> by 45-degrees:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-5.png" alt="rotate y axis labels yticks">
Now, let's work directly with the <code>Axes</code> object:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

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

plt.plot(x, y)

ax = plt.gca()
plt.draw()

ax.set_yticklabels(ax.get_yticks(), rotation = 45)

plt.show()
</code></pre>
The same note applies here, you have to call <code>plt.draw()</code> before this call to make it work correctly.
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-6.png" alt="rotate y axis labels with yticklabels">
Now, let's iterate over the list of <code>tick</code>s and <code>set_rotation()</code> on each of them:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

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

plt.plot(x, y)

ax = plt.gca()
plt.draw()

for tick in ax.get_yticklabels():
 tick.set_rotation(45)
plt.show()
</code></pre>
This also results in:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-7.png" alt="rotate y axis labels with set_rotation">
And finally, you can use the <code>ax.tick_params()</code> function and set the label rotation there:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

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

plt.plot(x, y)

ax = plt.gca()
ax.tick_params(axis=&#x27;y&#x27;, labelrotation = 45)
plt.show()
</code></pre>
This also results in:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-7.png" alt="rotate y axis labels with tick_params">
<h2 id="rotatedatestofitinmatplotlib">Rotate Dates to Fit in Matplotlib</h2>
Most often, the reason people rotate ticks in their plots is because they contain dates. Dates can get long, and even with a small dataset, they'll start overlapping and will quickly become unreadable.
Of course, you can rotate them like we did before, usually, a 45-degree tilt will solve most of the problems, while a 90-degree tilt will free up even more.
Though, there's another option for rotating and fixing dates in Matplotlib, which is even easier than the previous methods - <code>fig.autofmt__date()</code>.
This function can be used either as <code>fig.autofmt_xdate()</code> or <code>fig.autofmt_ydate()</code> for the two different axes.
Let's take a look at how we can use it on the <a rel="nofollow noopener" target="_blank" href="https://www.kaggle.com/rtatman/did-it-rain-in-seattle-19482017">Seattle Weather Dataset</a>:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt

weather_data = pd.read_csv(&quot;seattleWeather.csv&quot;)

fig = plt.figure()
plt.plot(weather_data[&#x27;DATE&#x27;], weather_data[&#x27;PRCP&#x27;])
fig.autofmt_xdate()
plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-8.png" alt="auto format dates to fit in matplotlib">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to rotate Axis text/labels in a Matplotlib plot, including a specific way to format and fit dates .
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 examples on how to rotate the axis text or labels in a Matplotlib plot. We'll work on a figure-level and an axes-level, with several methods.

Rotate Axis Labels in Matplotlib

<h2 id="introduction">Introduction</h2>
Key-value stores are essential and often used, especially in operations that require fast and frequent lookups. They allow an object - the key - to be mapped to another object, the value. This way, the values can easily be retrieved, by looking up the key.
In Java, the most popular <code>Map</code> implementation is the <code>HashMap</code> class. Aside from key-value mapping, it's used in code that requires frequest insertions, updates and lookups. The insert and lookup time is a constant O(1).
In this tutorial, we'll go over how to get the Keys and Values of a map in Java.
<h2 id="getkeysandvaluesentriesfromjavamap">Get Keys and Values (Entries) from Java Map</h2>
Most of the time, you're storing key-value pairs because both pieces of info are important. Thus, in most cases, you'll want to get the key-value pair together.
The <code>entrySet()</code> method returns a set of <code>Map.Entry&lt;K, V&gt;</code> objects that reside in the map. You can easily iterate over this set to get the keys and their associated values from a map.
Let's populate a <code>HashMap</code> with some values:
<pre><code class="hljs">Map&lt;String, Integer&gt; map = new HashMap&lt;&gt;();
 
map.put(&quot;David&quot;, 24);
map.put(&quot;John&quot;, 35);
map.put(&quot;Jane&quot;, 19);
map.put(&quot;Billy&quot;, 21);
</code></pre>
Now, let's iterate over this map, by going over each <code>Map.Entry&lt;K,V&gt;</code> in the <code>entrySet()</code>, and extracing the key and value from each of those entries:
<pre><code class="hljs">for (Map.Entry&lt;String, Integer&gt; pair : map.entrySet()) {
 System.out.println(String.format(&quot;Key (name) is: %s, Value (age) is : %s&quot;, pair.getKey(), pair.getValue())); 
}
</code></pre>
This results in:
<pre><code class="hljs">Key (name) is: Billy, Value (age) is: 21
Key (name) is: David, Value (age) is: 24
Key (name) is: John, Value (age) is: 35
Key (name) is: Jane, Value (age) is: 19
</code></pre>
<h2 id="getkeysandvaluesentriesfromjavamapwithforeach">Get Keys and Values (Entries) from Java Map with forEach()</h2>
Java 8 introduces us to the <code>forEach()</code> method for collections. It accepts a <code>BiConsumer&lt;? super K, ? super V&gt; action</code>. The <code>forEach()</code> method performs the given <code>BiConsumer</code> action on each entry of the <code>HashMap</code>.
Let's use the same map from before, but this time, add a year to each of the entries' ages:
<pre><code class="hljs">map.forEach((key, value) -&gt; System.out.println(key + &quot; : &quot; + value));
</code></pre>
This prints out:
<pre><code class="hljs">Billy : 21
David : 24
John : 35
Jane : 19
</code></pre>
Or, instead of consuming each <code>key</code> and <code>value</code> from the map, you can use a regular <code>Consumer</code> and just consume entire entries from the <code>entrySet()</code>:
<pre><code class="hljs">map.entrySet()
 .forEach((entry) -&gt; System.out.println(entry.getKey() + &quot; : &quot; + entry.getValue()));
</code></pre>
This also results in:
<pre><code class="hljs">Billy : 21
David : 24
John : 35
Jane : 19
</code></pre>
<h2 id="getkeysfromajavamap">Get Keys from a Java Map</h2>
To retrieve just keys, if you don't really need any information from the values, instead of the entry set, you can get the key set:
<pre><code class="hljs">for(String key: map.keySet()){
 System.out.println(key);
}
</code></pre>
Output:
<pre><code class="hljs">Billy
David
John
Jane
</code></pre>
<h2 id="getvaluesfromajavamap">Get Values from a Java Map</h2>
Similarly, one may desire to retrieve and iterate through the values only, without the keys. For this, we can use <code>values()</code>:
<pre><code class="hljs">for(String value: map.values()){
 System.out.println(value);
}
</code></pre>
Output:
<pre><code class="hljs">21
54
35
19
</code></pre>
<h2 id="checkifmapcontainsakey">Check if Map Contains a Key</h2>
The <code>HashMap</code> class has a <code>containsKey()</code> method, which checks if the passed key exists in the <code>HashMap</code>, and returns a boolean value signifying the presence of the element or lack thereof.
Let's check if a key, <code>5</code> exists:
<pre><code class="hljs">boolean result = map.containsKey(5);
System.out.println(result);
</code></pre>
This prints out:
<pre><code class="hljs">false
</code></pre>
And for an existing key:
<pre><code class="hljs">boolean result = map.containsKey(&quot;John&quot;);
System.out.println(result);
</code></pre>
This prints out:
<pre><code class="hljs">true
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over a few ways to get keys and values (entries) of a Map in Java. We've covered using an iterator and going through each <code>Map.Entry&lt;K, V&gt;</code>, as well as using a <code>forEach()</code> method both on the map itself, as well as its entry set.
Finally, we've gone over how to get the key set and values separately, and check if a map contains a given key.

In this tutorial, we'll go over examples on how to get the keys and values (entries) of a map in Java. We'll use forEach as well as iterators.