<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 change the background of a plot in Matplotlib.
<h2 id="importingdataandlibraries">Importing Data and Libraries</h2>
Let's import the required libraries first. We'll obviously need Matplotlib, and we'll use Pandas to read the data:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd
</code></pre>
Specifically, we'll be using 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">weather_data = pd.read_csv(&quot;seattleWeather.csv&quot;)
print(weather_data.head())
</code></pre>
<pre><code class="hljs"> DATE PRCP TMAX TMIN RAIN
0 1948-01-01 0.47 51 42 True
1 1948-01-02 0.59 45 36 True
2 1948-01-03 0.42 45 35 True
3 1948-01-04 0.31 45 34 True
4 1948-01-05 0.17 45 32 True
</code></pre>
<h2 id="creatingaplot">Creating a Plot</h2>
Now, let's create a simple <a target="_blank" href="/matplotlib-scatterplot-tutorial-and-examples/">Matplotlib Scatter Plot</a>, with a few different variables we want to visualize:
<pre><code class="hljs">PRCP = weather_data[&#x27;PRCP&#x27;]
TMAX = weather_data[&#x27;TMAX&#x27;]
TMIN = weather_data[&#x27;TMIN&#x27;]
</code></pre>
Now, we'll construct a scatter plot between the minimum temperature and precipitation and <code>show()</code> it using Matplotlib's PyPlot:
<pre><code class="hljs">plt.scatter(TMIN, PRCP)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-change-plot-background-in-matplotlib-1.png" alt="matplotlib scatter plot">
The graph that we have produced is interpretable, but it is looking a little plain. Let's try customizing it. We want to customize the background of our plot using a couple of different methods.
<h2 id="changeplotbackgroundinmatplotlib">Change Plot Background in Matplotlib</h2>
Now, let's go ahead and change the background of this plot. We can do this with two different approaches. We can change the color of the face, which is currently set to <code>white</code>. Or, we can input a picture using <code>imshow()</code>.
<h3 id="changeaxesbackgroundinmatplotlib">Change Axes Background in Matplotlib</h3>
Let's first change the color of the face. This can either be done with the <code>set()</code> function, passing in the <code>face</code> argument and its new value, or via the dedicated <code>set_facecolor()</code> function:
<pre><code class="hljs">ax = plt.axes()
ax.set_facecolor(&quot;orange&quot;)
# OR
ax.set(facecolor = &quot;orange&quot;)

plt.scatter(TMIN, PRCP)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-change-plot-background-in-matplotlib-2.png" alt="change axes background color matplotlib">
Either of these approaches produces the same result, as they both call on the same function under the hood.
<h3 id="changefigurebackgroundinmatplotlib">Change Figure Background in Matplotlib</h3>
If you would like to set the background for the figure and need the axes to be transparent, this can be done with the <code>set_alpha()</code> argument when you create the figure. Let's create a figure and an axes object. Of course, you can also use the <code>set()</code> function, and pass the <code>alpha</code> attribute instead.
The color of the entire figure will be blue and we will initially set the <code>alpha</code> of the axes object to <code>1.0</code>, meaning fully opaque. We color the axes object orange, giving us an orange background within the blue figure:
<pre><code class="hljs">fig = plt.figure()
fig.patch.set_facecolor(&#x27;blue&#x27;)
fig.patch.set_alpha(0.6)

ax = fig.add_subplot(111)
ax.patch.set_facecolor(&#x27;orange&#x27;)
ax.patch.set_alpha(1.0)

plt.scatter(TMIN, PRCP)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-change-plot-background-in-matplotlib-3.png" alt="change figure background matplotlib">
Now let's see what happens when we adjust the alpha of the axes subplot down to <code>0.0</code>:
<pre><code class="hljs">fig = plt.figure()
fig.patch.set_facecolor(&#x27;blue&#x27;)
fig.patch.set_alpha(0.6)

ax = fig.add_subplot(111)
ax.patch.set_facecolor(&#x27;orange&#x27;)
ax.patch.set_alpha(0.0)

plt.scatter(TMIN, PRCP)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-change-plot-background-in-matplotlib-4.png" alt="change axes background matplotlib within figure">
Notice that the background of the plot itself is transparent now.
<h3 id="addimagetoplotbackgroundinmatplotlib">Add Image to Plot Background in Matplotlib</h3>
If you would like to use an image as the background for a plot, this can be done by using PyPlot's <code>imread()</code> function. This function loads an image into Matplotlib, which can be displayed with the function <code>imshow()</code>.
In order to plot on top of the image, the extent of the image has to be specified. By default, Matplotlib uses the upper left corner of the image as the image's origin. We can give a list of points to the <code>imshow()</code> function, specifying what region of the image should be displayed. When combined with subplots, another plot can be inserted on top of the image.
Let's use an image of rain as the background for our plot:
<pre><code class="hljs">img = plt.imread(&quot;rain.jpg&quot;)
fig, ax = plt.subplots()
ax.imshow(img, extent=[-5, 80, -5, 30])
ax.scatter(TMIN, PRCP, color=&quot;#ebb734&quot;)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-change-plot-background-in-matplotlib-5.png" alt="adding image to background matplotlib">
The <code>extent</code> argument takes in additional arguments in this order: <code>horizontal_min</code>, <code>horizontal_max</code>, <code>vertical_min</code>, <code>vertical_max</code>).
Here, we've read the image, cropped it and showed it on the axes using <code>imshow()</code>. Then, we plotted the scatter plot with a different color and showed the plot.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to change the background of a plot using Python and Matplotlib.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 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>

Dan Nelson

In this tutorial, we'll go over several examples of how to change the background of a plot (figure background and axes background) in Matplotlib using Python.

How to Change Plot Background in Matplotlib

<h2 id="introduction">Introduction</h2>
Sorting data is a frequent problem in computer science. Given a collection of elements, the goal is to rearrange them in some order. Common examples are sorting an array alphabetically or from smallest to largest.
Sorted data is a lot easier to manipulate. Finding the largest or smallest element of an array can be done in constant time if the array is sorted. Searching for an element is a lot faster using algorithms such as <a rel="nofollow" target="_blank" href="/binary-search-in-java/">Binary Search</a> which rely on the assumption that the array is already sorted.
One of the simplest algorithms for sorting data is Selection Sort. It's usually taught in beginner programming classes and tutorials to explain the concept of sorting, so we'll keep this article very beginner-friendly.
<h2 id="selectionsort">Selection Sort</h2>
Selection sort is an in-place comparison sorting algorithm that uses brute force to sort an array.
<blockquote>
In-place means that the algorithm uses a small constant amount of space for extra storage.
</blockquote>
It's called a &quot;brute force&quot; algorithm because it uses the simplest and most ineffective way of calculating the solution. However, it does make up for it with its straightforward implementation.
The algorithm divides the array into two subarrays:
<ul>
<li>A sorted subarray</li>
<li>An unsorted subarray</li>
</ul>
The sorted subarray is empty in the beginning. In every iteration, the smallest element of the unsorted array will be appended to the end of the sorted array by swapping. This way, the sorted array will eventually contain all the elements of the original array.
An example array we want to sort in ascending order:
<table>
 <tr>
 <td>Sorted array</td>
 <td>Unsorted array</td>
 <td>Minimal element of the unsorted array</td>
 </tr>
 <tr>
 <td>[]</td>
 <td>[16, 5, 30, 6, 2, 7]</td>
 <td>2</td>
 </tr>
 <tr>
 <td>[2]</td>
 <td>[16, 5, 20, 6, 7]</td>
 <td>5</td>
 </tr>
 <tr>
 <td>[2, 5]</td>
 <td>[16, 20, 6, 7]</td>
 <td>6</td>
 </tr>
 <tr>
 <td>[2, 5, 6]</td>
 <td>[16, 7, 20]</td>
 <td>7</td>
 </tr>
 <tr>
 <td>[2, 5, 6, 7]</td>
 <td>[16, 20]</td>
 <td>16</td>
 </tr>
 <tr>
 <td>[2, 5, 6, 7, 16]</td>
 <td>[20]</td>
 <td>20</td>
 </tr>
 <tr>
 <td>[2, 5, 6, 7, 16, 20]</td>
 <td>[]</td>
 <td></td>
 </tr>
</table>
<h2 id="implementation">Implementation</h2>
The <code>selectionSort()</code> method takes just one argument, the array that needs to be sorted. We'll iterate through the unsorted array, which will be between indexes <code>i</code> and <code>j</code>, find its minimum and place it into the sorted array by swapping:
<pre><code class="hljs">public static void selectionSort(int[] nums) {
 for (int i = 0; i &lt; nums.length; i++) {
 // min is the index of the smallest element with an index greater or equal to i
 int min = i;
 for (int j = i + 1; j &lt; nums.length; j++) {
 if (nums[j] &lt; nums[min]) {
 min = j;
 }
 }
 // Swapping i-th and min-th elements
 int swap = nums[i];
 nums[i] = nums[min];
 nums[min] = swap;
 }
}
</code></pre>
Let's test out the code:
<pre><code class="hljs">int[] array = new int[]{16, 5, 30, 6, 7, 2};
selectionSort(array);
System.out.println(Arrays.toString(array));
</code></pre>
This will print out:
<pre><code class="hljs">[2, 5, 6, 7, 16, 30]
</code></pre>
<h2 id="selectionsorttimecomplexity">Selection Sort Time Complexity</h2>
Time complexity is a way to describe how much time an algorithm needs to finish executing relative to the size of the input. Analyzing the time it takes for an algorithm to give output is of crucial importance. Imagine a telephone book application that would take a day to sort all the numbers after a new number was added. That would be way less useful than the same app that would do it almost instantly.
Performance depends on the hardware as well as software, but the same program can be run on many different types of hardware. The Big-O notation makes it easier to approximate the time needed for a program to execute, regardless of software.
The average and worst-case time complexity of Selection Sort is O(n2). This makes Selection Sort a lot slower than many other comparison sorting algorithms like <a target="_blank" href="/merge-sort-in-java/">Merge Sort</a> or <a target="_blank" href="/merge-sort-in-java/">Insertion Sort</a> which have the worst-case time complexity (O(nlogn)). Interestingly, O(nlogn) is the best that can be achieved by any comparison sorting algorithm.
<h2 id="timecomplexityanalysis">Time Complexity Analysis</h2>
Showing that Selection Sort has quadratic time complexity comes down to calculating the number of times the inner loop will be iterated. We can see this if we go through the code line by line and try to approximate the time it takes to execute each line of code:
<pre><code class="hljs">for (int i = 0; i &lt; nums.length; i++) {
</code></pre>
Everything in the inner block of the loop will be executed <code>n</code> times, where <code>n</code> is the length of a given array:
<pre><code class="hljs">int min = i;
</code></pre>
<code>min</code> will be initialized to <code>i</code> exactly <code>n</code> times. Now comes the tricky part:
<pre><code class="hljs">for (int j = i + 1; j &lt; nums.length; j++)
</code></pre>
Since this loop is nested, it takes a bit of math to calculate the number of times the block of code inside it will execute. Let's work it out.
When <code>i</code> is equal to 0, <code>j</code> will go from 1 to <code>n</code>, meaning every instruction in the inner block will execute <code>n</code> times. When <code>i</code> increases to 1, <code>j</code> will stay between 2 and <code>n</code>, which implies the inner block will execute <code>n-2</code> times. Summing this up:
<pre><code class="hljs">(n - 1) + (n - 2) + ... + 1
</code></pre>
The sum of a sequence of natural numbers is calculated using something called Gauss's trick, and it results in (n2 - n)/2. Simplifying this, results in O(n2) time complexity.
<blockquote>
Put simply, when calculating the complexity of an algorithm O(f(n)), we need to look for the highest power of n in the function f(n) and isolate it. This is because any part of the equation that has a lower power will not affect the result in any significant way.
For example, we have the function f(x) = x2+13x+23
O(f(x)) would be the highest power of x in the equation, which in this case is x2.
</blockquote>
Here's how it performed after sorting an array containing 10,000 integers in random order:
<pre><code class="hljs">public static void main(String[] args) {
 int[] array = new int[10000];
 for (int i = 0; i &lt; array.length; i++) {
 array[i] = i;
 }

 // Shuffle array
 Collections.shuffle(Arrays.asList(array));

 // Print shuffled collection
 System.out.println(Arrays.toString(array));
 
 long startTime = System.nanoTime();
 selectionSort(array);
 long endTime = System.nanoTime();
 
 // Print sorted collection
 System.out.println(Arrays.toString(array));

 // Print runtime in seconds
 System.out.println(&quot;Selection Sort runtime: &quot; + (endTime - startTime)/1000000000);
}
</code></pre>
Running it 10 times, this code produced the following results:
<table class="table table-striped">
 <tr>
 <td>Time(s)</td>
 <td>Selection Sort</td>
 </tr>
 <tr>
 <td>First Run</td>
 <td>0.024</td>
 </tr>
 <tr>
 <td>Second Run</td>
 <td>0.020</td>
 </tr>
 <tr>
 <td>Third Run</td>
 <td>0.022</td>
 </tr>
 <tr>
 <td>Fourth Run</td>
 <td>0.020</td>
 </tr>
 <tr>
 <td>Fifth Run</td>
 <td>0.025</td>
 </tr>
 <tr>
 <td>Sixth Run</td>
 <td>0.022</td>
 </tr>
 <tr>
 <td>Seventh Run</td>
 <td>0.021</td>
 </tr>
 <tr>
 <td>Eight Run</td>
 <td>0.031</td>
 </tr>
 <tr>
 <td>Ninth Run</td>
 <td>0.022</td>
 </tr>
 <tr>
 <td>Tenth Run</td>
 <td>0.029</td>
 </tr>
</table>
The average run time was 0.0236 seconds, though, this will majorly depend on your machine as well.
<h2 id="selectionsortspacecomplexity">Selection Sort Space Complexity</h2>
Space Complexity is also a big factor in algorithm design. Our programs are bound, not only by the time that they need to execute but also by memory usage. There is a limited amount of memory on any computer, so a programmer should keep an eye on that too.
The space complexity of Selection Sort is constant(O(1)) because it is in-place, which is great. Worst case complexity of Selection Sort is, unfortunately, O(n2) as well, which means that even if the algorithm gets an already sorted array as input, it will still take a lot of time to return the unchanged array.
This algorithm has decent performance if the collection doesn't have a lot of elements. If the array has ~10 elements, the difference in performance between different sorting algorithms shouldn't be that noticeable, and Selection Sort might even outperform other divide-and-conquer algorithms.
Where Selection Sort shines, is when the number of swaps needs to be minimal. In the worst case, there will only be <code>n-1</code> swaps, which is the minimal possible number of swaps that need to be performed. This is quite intuitive if we consider that every element will be placed in its right spot in the sorted array right away.
<h2 id="conclusion">Conclusion</h2>
Selection Sort is a brute force in-place comparison sort which continuously finds the minimum of an unsorted subarray and places it in the correct position in the sorted subarray. Due to its simplicity, it's often one of the first algorithms that are taught in computer science courses all around the world.
Even if more efficient algorithms come built-it, it's still important to understand the underlying logic and complexity analysis to avoid common issues and to make sure that the tool being used is the one that's best suited for the job at hand.

Kristina Popovic

In this tutorial, we'll go over the theory and implementation of Selection Sort in Java. We'll also explore its time and space complexity with examples.

Selection Sort in Java

Marcus Sanatan

Ruslan Hasanov

WTForms is a popular Python library that validates form data. This tutorial shows you how to use WTForms with Flask to create and verify forms in your app.

Flask Form Validation with WTForms

Flask Form Validation with Flask-WTF

<h2 id="introduction">Introduction</h2>
Whether in Java, or any other programming language, it is a common occurrence to check if an array contains a value. This is one of the things that most beginners tend to learn, and it is a useful thing to know in general.
In this article, we'll take a look at how to check if an array contains a value or element in Java.
<ul>
<li><a href="#arraysaslistcontains">Arrays.asList().contains()</a></li>
<li><a href="#usingaforloop">Using a for-loop</a></li>
<li><a href="#collectionsbinarysearch">Collections.binarySearch()</a></li>
<li><a href="#java8streamapi">Java 8 Stream API</a></li>
<li><a href="#apachecommonsarrayutils">Apache Commons - ArrayUtils</a></li>
</ul>
<h2 id="arraysaslistcontains">Arrays.asList().contains()</h2>
This is perhaps the most common way of solving this problem, just because it performs really well and is easy to implement.
First, we convert the array to an <code>ArrayList</code>. There are various ways to <a target="_blank"
href="/how-to-convert-a-java-array-to-arraylist/">convert a Java array to an ArrayList</a>, though, we'll be using the most widely used approach.
Then, we can use the <code>contains()</code> method on the resulting <code>ArrayList</code>, which returns a boolean signifying if the list contains the element we've passed to it or not.
Array of an <code>Integer</code> type:
<pre><code class="hljs">Integer[] intArray = new Integer[]{1, 2, 3, 4, 5};
String[] nameArray = new String[]{&quot;John&quot;, &quot;Mark&quot;, &quot;Joe&quot;, &quot;Bill&quot;, &quot;Connor&quot;};

List&lt;Integer&gt; intList = new ArrayList&lt;&gt;(Arrays.asList(intArray));
List&lt;String&gt; nameList = new ArrayList&lt;&gt;(Arrays.asList(nameArray));

System.out.println(intList.contains(12));
System.out.println(nameList.contains(&quot;John&quot;));
</code></pre>
Running this code results in:
<pre><code class="hljs">false
true
</code></pre>
<h2 id="usingaforloop">Using a for-loop</h2>
A more basic and manual approach to solving the problem is by using a <code>for</code> loop. In worst case, it'll iterate the entire array once, checking if the element is present.
Let's start out with primitive integers first:
<pre><code class="hljs">int[] intArray = new int[]{1, 2, 3, 4, 5};
boolean found = false;
int searchedValue = 2;

for(int x : intArray){
 if(x == searchedValue){
 found = true;
 break;
 }
}

System.out.println(found);
</code></pre>
The <code>found</code> variable is initially set to <code>false</code> because the only way to return <code>true</code> would be to find the element and explicitly assign a new value to the boolean. Here, we simply compare each element of the array to the value we're searching for, and return <code>true</code> if they match:
<pre><code class="hljs">true
</code></pre>
For Strings, and custom Objects you might have in your code, you'd be using a different comparison operator. Assuming you've validly ovverriden the <code>equals()</code> method, you can use it to check if an object is equal to another, returning <code>true</code> if they are:
<pre><code class="hljs">String[] stringArray = new String[]{&quot;John&quot;, &quot;Mark&quot;, &quot;Joe&quot;, &quot;Bill&quot;, &quot;Connor&quot;};
boolean found = false;
String searchedValue = &quot;Michael&quot;;

for(String x : stringArray){
 if(x.equals(searchedValue)){
 found = true;
 break;
 }
}

System.out.println(found);
</code></pre>
Running this code will result in:
<pre><code class="hljs">false
</code></pre>
<h2 id="collectionsbinarysearch">Collections.binarySearch()</h2>
Additionally, we can find a specific value using a built-in method <code>binarySearch()</code> from the <code>Collections</code> class. The problem with binary search is that it requires our array be sorted. If our array is sorted though, <code>binarySearch()</code> outperforms both the <code>Arrays.asList().contains()</code> and the for-loop approaches.
If it's not sorted, the added time required to sort the array might make this approach less favorable, depending on the size of the array and the sorting algorithm used to sort it.
<code>binarySearch()</code> has many overloaded variants depending on the types used and our own requirements, but the most general one is:
<pre><code class="hljs">public static int binarySearch(Object[] a, Object[] key)
</code></pre>
Where <code>a</code> represents the array, and <code>key</code> the specified value we're looking for.
Now, the return value might be a bit confusing, so it's best to take Oracle's official documentation in mind:
<blockquote>
The return value of this method is the index of the searched key, if it is contained in the array; otherwise (-(insertion point) - 1), where insertion point is defined as the point at which the key would be inserted into the array: the index of the first element greater than the key, or <code>a.length</code> if all elements in the array are less than the specified key.
</blockquote>
Let's try this out:
<pre><code class="hljs">Integer[] intArray = new Integer[]{1, 2, 3, 4, 5};
String[] nameArray = new String[]{&quot;Bill&quot;, &quot;Connor&quot;, &quot;Joe&quot;, &quot;John&quot;, &quot;Mark&quot;}; // Array is already sorted lexicographically

List&lt;Integer&gt; intList = new ArrayList&lt;&gt;(Arrays.asList(intArray));
List&lt;String&gt; nameList = new ArrayList&lt;&gt;(Arrays.asList(nameArray));
System.out.println(Collections.binarySearch(intList, 2));
System.out.println(Collections.binarySearch(nameList, &quot;Robin&quot;));
</code></pre>
This will output:
<pre><code class="hljs">1
-6
</code></pre>
The first element is found, at position <code>1</code>. The second element isn't found, and would be inserted at position <code>5</code> - at the end of the array. The return value is <code>-(insertion point)-1</code>, so the return value ends up being <code>-6</code>.
If the value is above equal to, or above <code>0</code>, the array contains the element, and it doesn't contain it otherwise.
<h2 id="java8streamapi">Java 8 Stream API</h2>
The Java 8 Stream API is very versatile and offers for concise solutions to various tasks related to processing collections of objects. Using Streams for this type of task is natural and intuitive for most.
Let's take a look at how we can use the Stream API to check if an array contains an integer:
<pre><code class="hljs">Integer[] arr = new Integer[]{1, 2, 3, 4, 5};

System.out.println(Arrays.stream(arr).anyMatch(x -&gt; x == 3));
</code></pre>
This will output:
<pre><code class="hljs">true
</code></pre>
And to do this with Strings or custom objects:
<pre><code class="hljs">String[] arr = new String[]{&quot;John&quot;, &quot;Mark&quot;, &quot;Joe&quot;, &quot;Bill&quot;, &quot;Connor&quot;};

String searchString = &quot;Michael&quot;;

boolean doesContain = Arrays.stream(arr)
 .anyMatch(x -&gt; x.equals(searchString));

System.out.println(doesContain);
</code></pre>
Or, you can make this shorter by using a method reference:
<pre><code class="hljs">boolean doesContain = Arrays.stream(arr)
 .anyMatch(searchString::equals);
 
System.out.println(doesContain);
</code></pre>
Both of these would output:
<pre><code class="hljs">false
</code></pre>
<h2 id="apachecommonsarrayutils">Apache Commons - ArrayUtils</h2>
The <a rel="nofollow noopener" target="_blank" href="https://commons.apache.org/">Apache Commons</a> library provides many new interfaces, implementations and classes that expand on the core Java Framework, and is present in many projects.
The <code>ArrayUtils</code> class introduces many methods for manipulating arrays, including the <code>contains()</code> method:
<pre><code class="hljs">Integer[] intArray = new Integer[]{1, 2, 3, 4, 5};
String[] nameArray = new String[]{&quot;John&quot;, &quot;Mark&quot;, &quot;Joe&quot;, &quot;Bill&quot;, &quot;Connor&quot;};

System.out.println(ArrayUtils.contains(intArray, 3));
System.out.println(ArrayUtils.contains(nameArray, &quot;John&quot;));
</code></pre>
This would result in:
<pre><code class="hljs">true
true
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over several ways to check whether an array in Java contains a certain element or value. We've gone over converting the array to a list and calling the <code>contains()</code> method, using a for-loop, the Java 8 Stream API, as well as Apache Commons.

Branko Ilic

In this tutorial, we'll go over examples of how to check if a Java array contains a certain element or value. We'll be using a List, the Stream API as well as Apache Commons.

Java: Check if Array Contains Value or Element

Sathiya Sarathi Gunasekaran

This article will give you a crash course on web scraping in Python with Beautiful Soup - a popular Python library for parsing HTML and XML.

Parsing HTML with BeautifulSoup in Python

Guide to Parsing HTML with BeautifulSoup in Python

<h2 id="introduction">Introduction</h2>
The main purpose of writing code is so that a computer can interpret it as commands. However, it's also important that the code we write is also easily interpretable by fellow developers.
Have you ever gone back to a project and had difficulty understanding the internal logic? Well that's probably because said project hasn't been commented properly.
Comments are notes written in the code that are ignored by the JavaScript engine, which means they don't affect the output in any way. Their sole purpose is describing how and why code works to other developers, and yourself.
In this article, we will look at how to comment JavaScript code, as which types of comments exist, and some best practices.
<h2 id="singlelinecomments">Single-Line Comments</h2>
Single-line comments are generally used to comment a part of the line or full line of code. Single-line comments in JavaScript start with <code>//</code>. The interpreter will ignore everything to the right of this control sequence until the end of the line.
Let's see an example of a single-line comment in action:
<pre><code class="hljs">// Print &quot;Hello World&quot; in the console
console.log(&quot;Hello World&quot;);
</code></pre>
Here, we are using a single-line comment to describe what the next line of code is doing. 
If a single-line comment appears at the end of a line of code, it's called an inline comment.
These are generally used to add quick annotations:
<pre><code class="hljs">let c = a + b; // Assign sum of a, b to c
</code></pre>
<h2 id="multilinecommentsandjavascriptdocstrings">Multi-Line Comments and JavaScript DocStrings</h2>
If we'd like to add a note that is spread across multiple lines, we can opt for multi-line comments or block-level comments.
Multi-line comments start with <code>/*</code> and end with <code>*/</code>:
<pre><code class="hljs">/* The following program contains source code for a game called Tic-tac-toe.
It is a paper-and-pencil game for two players, X and O, who take turns marking the spaces in a 3×3 grid. 
The player who succeeds in placing three of their marks in a horizontal, vertical, or diagonal row is the winner
*/
</code></pre>
Here, a multi-line comment is used to describe tic-tac-toe. Generally, multi-line comments are used to introduce and explain a section of code, where a single line/sentence isn't enough.
Another type of multi-line comment can oftentimes be seen as well:
<pre><code class="hljs">/**
* The following program contains source code for a game called Tic-tac-toe.
* It is a paper-and-pencil game for two players, X and O, who take turns marking the
* spaces in a 3×3 grid. 
* The player who succeeds in placing three of their marks in a horizontal, vertical, or 
* diagonal row is the winner
*/
</code></pre>
Oftentimes, these comments can include information about the proceeding code, such as the parameters of a function or even the author of the code:
<pre><code class="hljs">/**
* Function that greets a user
* @author John
* @param {String} name Name of the user
* @return {String} Greeting message
*/
function greetUser(name) {
 return `Greetings, ${name}!`;
}
</code></pre>
These comments are referred to as DocStrings, as they're essentially strings (comments) that constitute the documentation of your code.
These types of comments are really useful for other developers in your team, as you can clarify what the expected input is, what the output is, as well as who to contact if need be.
An added benefit is that you can generate documentation based on these DocStrings.
<h2 id="usingcommentsfordebugging">Using Comments for Debugging</h2>
Besides making notes, comments can also be used to quickly prevent code execution for debugging purposes. This is possible because JavaScript Engines do not interpret commented code. This is called as commenting out code.
If there's an erroneous line, that's causing problems, we can simply &quot;comment it out&quot; to disable it, without deleting the line. This can be paired with actual debuggers to help you assess what's going on.
Consider the following code:
<pre><code class="hljs">console.log(&quot;Working code&quot;);
console.log(&quot;Erroneous code);
</code></pre>
If we'd like to remove the second statement, but don't wish to delete it forever, we can simply comment it out:
<pre><code class="hljs">console.log(&quot;Working code&quot;);
//console.log(&quot;Erroneous code);
</code></pre>
Pro Tip: In most of the code editors, we can use the keyboard shortcut <code>Ctrl + /</code> for Windows and <code>Cmd + /</code> for Mac to comment out a single line of code.
Additionally, you can also comment out entire sections if you're unsure whether you'll delete them or not:
<pre><code class="hljs">/*console.log(&quot;Entering for loop&quot;);
for (let i = 0; i &lt; 100; i++) {
 console.log(i);
}*/
</code></pre>
<h2 id="goodcommentingpractices">Good Commenting Practices</h2>
First of all, commenting is not an excuse to write unreadable code, and then just patch it up with five paragraphs of comments explaining it. We first have to focus on writing clean, self-explanatory code, which can later be improved with constructive comments.
Use comments to explain why you did something, not how you did it. If you find yourself explaining how you did something, then it's time to take a step back and refactor your code into something self-explanatory.
Another piece of advice would be to not write comments which are obvious and are redundant by nature. For example, the following comment is completely unnecessary:
<pre><code class="hljs">// Prints out the result
console.log(result)
</code></pre>
There are useful tools, such as <a rel="nofollow noopener" target="_blank" href="https://github.com/jsdoc/jsdoc">JSDOC 3</a> that can generate documentation, based just on the comments within your code, which are formatted as DocStrings outlined above.
<h2 id="conclusion">Conclusion</h2>
In this article, we have gone over what comments are and how to create them in JavaScript. We have looked at different types of comments - single-line and multi-line comments, as well as mentioned JavaScript Docstrings.
We've also seen how to debug our code using a technique called &quot;commenting out&quot;, and finally summed up some good commenting practices.

Abhilash Kakumanu

In this tutorial, we'll go over how to comment code in JavaScript. We'll go over the types of comments, including DocStrings, and some best practices for writing comments in JavaScript.

Commenting Code in JavaScript - Types and Best Practices

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll take a look at how to declare and initialize arrays in Java.
We declare an array in Java as we do other variables, by providing a type and name:
<pre><code class="hljs">int[] myArray;
</code></pre>
To initialize or instantiate an array as we declare it, meaning we assign values as when we create the array, we can use the following shorthand syntax:
<pre><code class="hljs">int[] myArray = {13, 14, 15};
</code></pre>
Or, you could generate a stream of values and assign it back to the array:
<pre><code class="hljs">int[] intArray = IntStream.range(1, 11).toArray();
int[] intArray = IntStream.rangeClosed(1, 10).toArray();
int[] intArray = IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).toArray();
</code></pre>
To understand how this works, read more to learn the ins and outs of array declaration and instantiation!
<ul>
<li><a href="#arraydeclarationinjava">Array Declaration in Java</a></li>
<li><a href="#arrayinitializationinjava">Array Initialization in Java</a></li>
<li><a href="#intstreamrange">IntStream.range()</a></li>
<li><a href="#intstreamrangeclosed">IntStream.rangeClosed()</a></li>
<li><a href="#intstreamof">IntStream.of()</a></li>
<li><a href="#javaarrayloopinitialization">Java Array Loop Initialization</a></li>
</ul>
<h2 id="arraydeclarationinjava">Array Declaration in Java</h2>
The declaration of an array object in Java follows the same logic as declaring a Java variable. We identify the data type of the array elements, and the name of the variable, while adding rectangular brackets <code>[]</code> to denote its an array.
Here are two valid ways to declare an array:
<pre><code class="hljs">int intArray[];
int[] intArray;
</code></pre>
The second option is oftentimes preferred, as it more clearly denotes of which type <code>intArray</code> is.
Note that we've only created an array reference. No memory has been allocated to the array as the size is unknown, and we can't do much with it.
<h2 id="arrayinitializationinjava">Array Initialization in Java</h2>
To use the array, we can initialize it with the <code>new</code> keyword, followed by the data type of our array, and rectangular brackets containing its size:
<pre><code class="hljs">int[] intArray = new int[10];
</code></pre>
This allocates the memory for an array of size <code>10</code>. This size is immutable.
Java populates our array with default values depending on the element type - <code>0</code> for integers, <code>false</code> for booleans, <code>null</code> for objects, etc. Let's see more of how we can instantiate an array with values we want.
The slow way to initialize your array with non-default values is to assign values one by one:
<pre><code class="hljs">int[] intArray = new int[10];
intArray[0] = 22;
</code></pre>
In this case, you declared an integer array object containing 10 elements, so you can initialize each element using its index value.
The most common and convenient strategy is to declare and initialize the array simultaneously with curly brackets <code>{}</code> containing the elements of our array.
The following code initializes an integer array with three elements - 13, 14, and 15:
<pre><code class="hljs">int intArray[] = {13, 14, 15};
</code></pre>
Keep in mind that the size of your array object will be the number of elements you specify inside the curly brackets. Therefore, that array object is of size three.
This method work for objects as well. If we wanted to initialize an array of three Strings, we would do it like this:
<pre><code class="hljs">int[] stringArray = {&quot;zelda&quot;, &quot;link&quot;, &quot;ganon&quot;};
</code></pre>
Java allows us to initialize the array using the <code>new</code> keyword as well:
<pre><code class="hljs">int[] intArray = new int[]{13, 14, 15};
String[] stringArray = new String[]{&quot;zelda&quot;, &quot;link&quot;, &quot;ganon&quot;};
</code></pre>
It works the same way.
Note: If you're creating a method that returns an initialized array, you will have to use the <code>new</code> keyword with the curly braces. When returning an array in a method, curly braces alone won't work:
<pre><code class="hljs">public String[] getNames() {
 return new String[]{&quot;zelda&quot;, &quot;link&quot;, &quot;ganon&quot;}; // Works
}

public String[] getNames() {
 return {&quot;zelda&quot;, &quot;link&quot;, &quot;ganon&quot;}; // Doesn&#x27;t work
}
</code></pre>
<h2 id="intstreamrange">IntStream.range()</h2>
If you're declaring and initializing an array of integers, you may opt to use the <code>IntStream</code> Java interface:
<pre><code class="hljs">int[] intArray = IntStream.range(1, 11).toArray();
</code></pre>
The above code creates an array of ten integers, containing the numbers 1 to 10:
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
</code></pre>
The <code>IntStream</code> interface has a <code>range()</code> method that takes the beginning and the end of our sequence as parameters. Keep in mind that the second parameter is not included, while the first is.
We then use the method <code>toArray()</code> method to convert it to an array.
Note: <code>IntStream</code> is just one of few classes that can be used to create ranges. You can also use a <code>DoubleStream</code> or <code>LongStream</code> in any of these examples instead.
<h2 id="intstreamrangeclosed">IntStream.rangeClosed()</h2>
If you'd like to override that characteristic, and include the last element as well, you can use <code>IntStream.rangeClosed()</code> instead:
<pre><code class="hljs">int[] intArray = IntStream.rangeClosed(1, 10).toArray();
</code></pre>
This produces an array of ten integers, from 1 to 10:
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
</code></pre>
<h2 id="intstreamof">IntStream.of()</h2>
The <code>IntStream.of()</code> method functions very similarly to declaring an array with some set number of values, such as:
<pre><code class="hljs">int[] intArray = new int[]{6, 2, 4, 5, 7};
</code></pre>
Here, we specify the elements in the <code>of()</code> call:
<pre><code class="hljs">int[] intArray = IntStream.of(6, 2, 4, 5, 7).toArray();
</code></pre>
This produces an array with the order of elements preserved:
<pre><code class="hljs">[6, 2, 4, 5, 7]
</code></pre>
Or, you could even call the <code>sorted()</code> method on this, to sort the array as it's being initialized:
<pre><code class="hljs">int[] intArray = IntStream.of(6, 2, 4, 5, 7).sorted().toArray();
</code></pre>
Which results in an array with this order of elements:
<pre><code class="hljs">[2, 4, 5, 6, 7]
</code></pre>
<h2 id="javaarrayloopinitialization">Java Array Loop Initialization</h2>
One of the most powerful techniques that you can use to initialize your array involves using a <code>for</code> loop to initialize it with some values.
Let's use a loop to initialize an integer array with values 0 to 9:
<pre><code class="hljs">int[] intAray = new int[10];	

for (int i = 0; i &lt; intArray.length; i++) {
 int_array[i] = i;
}
</code></pre>
This is identical to any of the following, shorter options:
<pre><code class="hljs">int[] intArray = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int[] intArray = new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int[] intArray = IntStream.rangeClosed(0, 9).toArray();
</code></pre>
A loop is more ideal than the other methods when you have more complex logic to determine the value of the array element.
For example, with a <code>for</code> loop we can do things like making elements at even indices twice as large:
<pre><code class="hljs">int[] intArray = new int[10];	

for (int i = 0; i &lt; intArray.length; i++) {
 if (i % 2 == 0) {
 int_array[i] = i * 2;
 } else {
 int_array[i] = i;
 }
}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we discovered the different ways and methods you can follow to declare and initialize an array in Java. We've used curly braces <code>{}</code>, the <code>new</code> keyword and <code>for</code> loops to initialize arrays in Java, so that you have many options for different situations!
We've also covered a few ways to use the <code>IntStream</code> class to populate arrays with ranges of elements.

Mohamed Echout

In this article, we'll go over how to declare and initialize an array in Java, with examples and best practices. We'll cover traditional array declaration and initialization, as well as IntStreams.

How to Declare and Initialize an Array in Java

<h2 id="introduction">Introduction</h2>
List concatenation the act of creating a single list from multiple smaller lists by daisy chaining them together.
There are many ways of concatenating lists in Python. Specifically, in this article, we'll be going over how to concatenate two lists in Python using the plus operator, unpack operator, multiply operator, manual for loop concatenation, the <code>itertools.chain()</code> function and the inbuilt list method <code>extend()</code>.
In all the code snippets below, we'll make use of the following lists:
<pre><code class="hljs">list_a = [1, 2, 3, 4]
list_b = [5, 6, 7, 8]
</code></pre>
<h2 id="plusoperatorlistconcatenation">Plus Operator List Concatenation</h2>
The simplest and most straightforward way to concatenate two lists in Python is the plus (<code>+</code>) operator:
<pre><code class="hljs">list_c = list_a + list_b
print (list_c)
</code></pre>
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8]
</code></pre>
<h2 id="unpackoperatorlistconcatenation">Unpack Operator List Concatenation</h2>
This method allows you to join multiple lists. It is a fairly new feature and only available from Python 3.6+. The unpacking operator, as the name implies, unpacks an <code>iterable</code> object into its elements. Unpacking is useful when we want to generate a plethora of arguments from a single list. For example:
<pre><code class="hljs">def foo(a, b, c, d):
 return a + b + c + d

# We want to use the arguments of the following list with the foo function.
# However, foo doesn&#x27;t take a list, it takes 4 numbers, which is why we need to
# unpack the list.
foo(*list_a)
# This is the same as if we were to call foo(1,2,3,4)
</code></pre>
<pre><code class="hljs">10
</code></pre>
In a nutshell, we use the list constructor (<code>[a,b..]</code>) and generate the elements of the new list in order by unpacking multiple lists one after another:
<pre><code class="hljs">list_c = [*list_a, *list_b, *list_a]
# This is the same as:
# list_c = [1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4]
print (list_c)
</code></pre>
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4]
</code></pre>
<h2 id="multiplyoperatorlistconcatenation">Multiply Operator List Concatenation</h2>
The multiply (<code>*</code>) operator is special case of list concatenation in Python. It is used to repeat a whole list multiple times (which is why it's denoted with a multiplication operator):
<pre><code class="hljs">print(list_a * 2)
</code></pre>
<pre><code class="hljs">[1, 2, 3, 4, 1, 2, 3, 4]
</code></pre>
<h2 id="forlooplistconcatenation">for loop List Concatenation</h2>
In this method we will go through one list while appending each of its elements to another list one by one. When the loop is over you will have a single list with all the desired elements:
<pre><code class="hljs">for i in list_b:
 list_a.append(i)
print (list_a)
</code></pre>
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8]
</code></pre>
<h2 id="itertoolschainlistconcatenation">itertools.chain() List Concatenation</h2>
This method works with <code>iterables</code>. It constructs and returns an iterator that can later be used to construct the chained list (think of it as an arrow which just memorizes the order of elements in the resulting list):
<pre><code class="hljs"># If we were to call itertools.chain() like so
iterator = itertools.chain([1, 2], [3, 4])

# Basically the iterator is an arrow which can give us the next() element in a sequence, so if we call a list() constructor with said iterable, it works like this:
list(iterator)
</code></pre>
Under the hood, something along these lines is what happens:
<pre><code class="hljs"># Iterator: The next element in this list is 1 
[1, 2], [3, 4]
 ^
# Iterator: The next element in this list is 2
[1, 2], [3, 4]
 ^
# Iterator: The next element in this list is 3 
[1, 2], [3, 4]
 ^
# Iterator: The next element in this list is 4 
[1, 2], [3, 4]
 ^
# So the list() call looks something like:
list([1,2,3,4])

# Keep in mind this is all pseudocode, Python doesn&#x27;t give the developer direct control over the iterator
</code></pre>
For this method, you will need to import <code>itertools</code>:
<pre><code class="hljs">import itertools

list_c = list(itertools.chain(list_a, list_b))
print (list_c)
</code></pre>
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8]
</code></pre>
<h2 id="extendlistconcatenation">extend() List Concatenation</h2>
This is aa built-it function that can be used to expand a list. Here we are expanding the first list by adding elements of the second list to it:
<pre><code class="hljs">list_a.extend(list_b)

print (list_a)
</code></pre>
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over five ways to concatenate two lists in Python - using the plus operator, the unpack operator, the multiply operator, a for loop, <code>itertools.chain()</code> and <code>extend()</code>.

Guest Contributor

In this tutorial, we'll go over multiple ways on how to concatenate multiple lists in Python. We'll go over the plus operator, multiply operator, for loop, itertools.chain() and extend().

How to Concatenate Two Lists in Python

<h2 id="introduction">Introduction</h2>
There are a number of different data visualization libraries for Python. Out of all of the libraries, however, Matplotlib is easily the most popular and widely used one. With Matplotlib you can create both simple and complex visualizations.
Jupyter notebooks are one of the most popular methods of sharing data science and data analysis projects, code, and visualization. Although you may know how to visualize data with Matplotlib, you may not know how to use Matplotlib in a Jupyter notebook.
In this article, we'll be covering how to use an IPython notebook to plot Matplotlib plots inline.
It will also cover the purpose of the Matplotlib “inline” and &quot;notebook&quot; magic methods, which are used to set Matplotlib backends.
<h2 id="settingupipython">Setting Up IPython</h2>
Jupyter notebooks are Interactive, and if they let you share your work with other programmers and analysts in a reproducible format. Yet before you can work with a Jupyter notebook <a rel="nofollow noopener" target="_blank" href="https://Jupyter.org/install">you need to install it</a>.
The simplest and easiest way to install a Jupyter notebook is with the use of a package manager. If you are using Conda you can install the Jupyter file system with the following command:
<pre><code class="hljs">$ conda install -c conda-forge notebook
</code></pre>
If you are using pip, you can install Jupyter with this command instead:
<pre><code class="hljs">$ pip install notebook
</code></pre>
After the Jupyter lab has been installed, you can launch an instance of a Jupyter notebook by opening up the command line and using the following intuitively named command prompt:
<pre><code class="hljs">Jupyter Notebook
</code></pre>
You can then access your Jupyter notebook by pointing your browser to the following URL:
<pre><code class="hljs">http://localhost:8888/tree?
</code></pre>
<h2 id="importingdataandvisualizingdata">Importing Data and Visualizing Data</h2>
We'll be making use of the famous <a rel="nofollow noopener" target="_blank" href="https://www.kaggle.com/jsphyg/tipping">Tips dataset</a>.
We'll import Pandas for reading the <code>.csv</code> file, as well as <code>matplotlib.pyplot</code> for visualization. After that, we can construct a <a target="_blank" href="/matplotlib-scatterplot-tutorial-and-examples/">simple scatter plot</a>:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-plot-inline-and-with-qt-matplotlib-with-ipython-and-jupyter-notebooks-1.png" alt="jupyter notebook matplotlib visualization">
This is how you'd usually visualize data in a Jupyter notebook. However, if you shared this notebook with someone in its current form - they'd have to run the code themselves to see the visualizations.
If you would like the visualizations themselves to be included in the notebook body, you make use of the <code>inline</code> command, which refers to a Matplotlib backend.
<h2 id="matplotlibbackends">Matplotlib Backends</h2>
Usually, displaying plots involves using the <code>show()</code> function from PyPlot. With Jupyter notebooks, this isn't necessary as the plots are displayed after running the cells containing the code that generates them. These plots are by default, displayed inline, which means, they're displayed in the notebook itself.
However, you can also display the plot outside of the notebook, which can be done by changing the Matplotlib backend. Jupyter automatically sets a Matplotlib backend, though, this can be overridden using magic functions, which are called with the <code>%</code> character.
<h3 id="matplotlibplotonexternalwindowusingipythonjupyter">Matplotlib Plot On External Window using IPython/Jupyter</h3>
Let's start off with trying to plot on an external window from the notebook:
<pre><code class="hljs">%matplotlib qt
</code></pre>
Here, we've told the Jupyter notebook to use Qt to generate the frame on our local machine instead. This function call is situated before the Matplotlib import:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-plot-inline-and-with-qt-matplotlib-with-ipython-and-jupyter-notebooks-2.png" alt="jupyter notebook qt plot externally matplotlib">
<h3 id="matplotlibplotinlineusingipythonjupyterinline">Matplotlib Plot Inline using IPython/Jupyter (inline)</h3>
Certain versions of Jupyter may not correctly set the backend for Matplotlib and fail to render graphs inline. In that case, the inline plotting can be forced in one of two ways.
You can set the <code>inline</code> function, instead of <code>qt</code> to force Jupyter to display the plots inline:
<pre><code class="hljs">%matplotlib inline
</code></pre>
This helps make sure that anyone who opens the notebook can see the visualizations, without needing to rerun the code cells:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-plot-inline-and-with-qt-matplotlib-with-ipython-and-jupyter-notebooks-3.png" alt="jupyter notebook plot inline matplotlib">
<h3 id="matplotlibplotinlineusingipythonjupyternotebook">Matplotlib Plot Inline using IPython/Jupyter (notebook)</h3>
The second method of rendering a Matplotlib plot within a notebook is to use the <code>notebook</code> backend:
<pre><code class="hljs">%matplotlib notebook
</code></pre>
Using <code>%matplotlib notebook</code> creates interactive plots that are embedded within the notebook itself, allowing those viewing the notebook to do things like resize the figure or zoom in on the figure:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-plot-inline-and-with-qt-matplotlib-with-ipython-and-jupyter-notebooks-4.png" alt="jupyter notebook plot inline matplotlib">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over how to plot externally (using Qt) and inline (using <code>inline</code> and <code>notebook</code> magic functions) in IPython/Jupyter notebooks.
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 inline plots using IPyhon/Jupyter notebooks, with Matplotlib in Python.
We'll cover how to plot externally using Qt, as well as inline.