<h2 id="introduction">Introduction</h2>
In this guide, we'll take a look at how to style a PyQt application.
<blockquote>
If you're unfamiliar with PyQt, read our <a target="_blank" href="https://stackabuse.com/working-with-pythons-pyqt-framework/">Guide to Working with Python's PyQT Framework</a>
</blockquote>
We'll start with PyQt's default themes and how to change these, before moving forward to using different types of custom styling.
<h2 id="defaultpyqtthemes">Default PyQt Themes</h2>
PyQt works with default OS-based themes. This means that not specifying a theme will give the application a different look on different systems.
Your application will look different on a Windows 10 machine as opposed to a Linux machine.
There are many styles or themes that ship with PyQt, other than the default themes.
To keep a uniform look and feel to our application while distributing to multiple operating systems we'll want to change the default theme with either a pre-built one or build our own. Alternatively, you can keep a native look depending on the operating system.
<h3 id="checkallavailablesystemstyles">Check All Available System-Styles</h3>
Since the default system styles differ from system to system, not every system will have the same default styles available.
Luckily, PyQt has a built-in function to retrieve all the available styles, kept in a dictionary. Let's take a look at all the available system styles:
<pre><code class="hljs"># The QStyleFactory object holds all the default system styles.
from PyQt6.QtWidgets import QStyleFactory
print(QStyleFactory.keys())
</code></pre>
On a Windows machine, this will return the three following styles:
<pre><code class="hljs">[&#x27;windowsvista&#x27;, &#x27;Windows&#x27;, &#x27;Fusion&#x27;]
</code></pre>
On Linux, on the other hand, it'll return:
<pre><code class="hljs">[&#x27;Breeze&#x27;, &#x27;Oxygen&#x27;, &#x27;QtCurve&#x27;, &#x27;Windows&#x27;, &#x27;Fusion&#x27;]
</code></pre>
To find out which default style is applied to an existing application, you can access the <code>objectName()</code> via <code>app.style()</code>:
<pre><code class="hljs">import sys
from PyQt6.QtWidgets import QApplication

app = QApplication(sys.argv)
print(app.style().objectName())
</code></pre>
The result, again, depends on your operating system:
<pre><code class="hljs">windowsvista
</code></pre>
<h3 id="applyingsystemstylestopyqt6applications">Applying System Styles to PyQt6 Applications</h3>
To change the default system style to another style we can use the <code>setStyle()</code> method on the <code>QApplication</code> instance,, with another style as an argument.
Let's set the default style to <code>Fusion</code> in a small application:
<pre><code class="hljs">import sys
from PyQt6.QtWidgets import QApplication, QPushButton, QVBoxLayout, QWidget
app = QApplication(sys.argv)

# Set the &#x27;Fusion&#x27; system style
app.setStyle(&#x27;Fusion&#x27;)

# Create the parent Widget of the Widgets added to the layout
window = QWidget()

# Create the Vertical Box Layout Manager, setting the window as parent by passing it in the constructor.
layout = QVBoxLayout(window)

# Create the button Widgets we will add to the layout.
# Add the button Widgets to the VerticalBoxLayout
layout.addWidget(QPushButton(&#x27;One&#x27;))
layout.addWidget(QPushButton(&#x27;Two&#x27;))
layout.addWidget(QPushButton(&#x27;Three&#x27;))
layout.addWidget(QPushButton(&#x27;Four&#x27;))
layout.addWidget(QPushButton(&#x27;Five&#x27;))

# Show the parent Widget
window.show()

# Launch the application
sys.exit(app.exec())
</code></pre>
Now, this applies the <code>Fusion</code> stylesheet to our elements, changing their appearance:
<img src="https://s3.stackabuse.com/media/articles/styling-pyqt6-applications-default-and-custom-qss-stylesheets-1.PNG" alt="fusion stylesheet pyqt6">
<h2 id="custompyqt6styles">Custom PyQt6 Styles</h2>
Although these styles are really nice - you might have a different vision for your application. What if you'd like to change the buttons to be red, but keep the rest of the Fusion stylesheet applied?
Much the same way you can stylize HTML pages - you can also stylize PyQt applications - inline and through QSS Stylesheets.
<blockquote>
QSS Stylesheets take inspiration from CSS Stlyesheets and have a borrowed syntax with a tiny tweak.
</blockquote>
<h3 id="addinginlinestyletopyqt6applications">Adding Inline Style to PyQt6 Applications</h3>
When the amount of styling code doesn't warrant a separate, standalone QSS File, it's easiest to write some styling code inline - that is, within the Python file in which your application resides.
Similar to styling HTML pages inline, it's not considered the best practice, but it is fine for prototyping, testing or really small tweaks.
Each <code>QWidget</code> accepts a <code>setStyleSheet()</code> function, which accepts a CSS string:
<pre><code class="hljs">widget.setStyleSheet(
 &quot;&quot;&quot;
 CSS SYNTAX
 &quot;&quot;&quot;
)
</code></pre>
For example, if we want to apply a color to a widget, set its font family and size, we can simply use the all-too-familiar CSS syntax:
<pre><code class="hljs">...
button = QPushButton(&#x27;One&#x27;)
button.setStyleSheet(
 &quot;background-color: #262626; &quot;
 &quot;font-family: times; &quot;
 &quot;font-size: 20px;&quot;
)

layout.addWidget(button)
</code></pre>
If we replaced the original button addition code with this, the application would look like:
<img src="https://s3.stackabuse.com/media/articles/styling-pyqt6-applications-default-and-custom-qss-stylesheets-2.PNG" alt="stylized button">
Now, if we want to style another component, we apply the <code>setStyleSheet()</code> function to it. This quickly becomes a problem if you want to style multiple components...
Although you can apply the <code>setStyleSheet()</code> function to the <code>QApplication</code> instance and apply styling globally to the entire application. Though, if you're already there, might as well create a new custom stylesheet and use it instead of inline styling code.
<h3 id="creatingcustomstylesheets">Creating Custom Stylesheets</h3>
The operating system styles are just stylesheets present in different shipments of PyQt. There's nothing stopping you from defining your own QSS Stylesheet made specifically for your application.
Additionally, using stylesheets fixes a myriad of problems that can arise from styling your components inline, besides the fact that it makes sense to separate business logic from styling code.
QSS files are very similar to CSS files - the only difference is how you identify elements you'd like to style. You can't assign a unique ID to a certain widget to style it individually. You'll have to lump together apples with apples and style widget types the same.
Optionally, you can also style objects within widgets individually from the widget itself:
<pre><code class="hljs">QPushButton {
 background-color: blue;
}

QLabel#title {
 font-size: 15px;
}
</code></pre>
The first style will define our background-color for all the <code>QPushButton</code> objects in the application.
The second style will only style the title object of a <code>QLabel</code>.
To include a QSS file to your application, you can apply it by reading the file and using the <code>QApplication.setStyleSheet(str)</code> function:
<pre><code class="hljs"># Open the qss styles file and read in the CSS-like styling code
with open(&#x27;styles.qss&#x27;, &#x27;r&#x27;) as f:
 style = f.read()

 # Set the stylesheet of the application
 app.setStyleSheet(style)
</code></pre>
Really, these files are just the container for our style strings.
<h3 id="stylingademonstrationapplication">Styling a Demonstration Application</h3>
With all of this in mind, let's create a simple QSS stylesheet and apply it to a simple demo application:
<pre><code class="hljs">import sys
from PyQt6.QtWidgets import (QApplication, QTableWidget, QTableWidgetItem)
from PyQt6.QtGui import QColor

# Declare our table values
nordic_countries = [(&#x27;Norway&#x27;, &#x27;Oslo&#x27;, &#x27;Yes&#x27;),
 (&#x27;Iceland&#x27;, &#x27;Reykjavik&#x27;, &#x27;Yes&#x27;),
 (&#x27;Denmark&#x27;, &#x27;Copenhagen&#x27;, &#x27;Yes&#x27;),
 (&#x27;Belgium&#x27;, &#x27;Brussels&#x27;,&#x27;No&#x27;)]
 
# Create the Qt Application
app = QApplication(sys.argv)

# Create the QTableWidget Widget
table = QTableWidget()

# Set the row count of the table to the length of the &#x27;nordic_countries&#x27; variable
table.setRowCount(len(nordic_countries))

# Since every country in our &#x27;nordic_countries&#x27; variable has the same amount of attributes
# we take the amount (3) of the first country and use this as the number of columns
table.setColumnCount(len(nordic_countries[0]))

# Set the Horizontal headers using setHorizontalHeaderLabels()
table.setHorizontalHeaderLabels([&#x27;Country&#x27;, &#x27;Capital&#x27;, &#x27;Scandinavian?&#x27;])

# Loop through every country in our &#x27;nordic_countries&#x27; variable
for i, (country, capital, scandinavian_bool) in enumerate(nordic_countries):

 # Make a QTableWidgetItem --&gt; acts as an item in a table
 item_country = QTableWidgetItem(country)
 item_capital = QTableWidgetItem(capital)
 item_scandinavian_bool = QTableWidgetItem(scandinavian_bool)

 # Set the value of the items
 table.setItem(i, 0, item_country)
 table.setItem(i, 1, item_capital)
 table.setItem(i, 2, item_scandinavian_bool)

# Finally show the table
table.show()

# Open the sqq styles file and read in the CSS-alike styling code
with open(&#x27;styles.qss&#x27;, &#x27;r&#x27;) as f:
 style = f.read()
 # Set the stylesheet of the application
 app.setStyleSheet(style)

# Launch the application
sys.exit(app.exec())
</code></pre>
And within the <code>styles.qss</code> file:
<pre><code class="hljs">QTableWidget {
 font-family: Titillium;
 font-size: 20px;
}

QTableWidget::item {
 background-color: #D3D3D3;

}

QTableWidget::item:hover {
 background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #e7effd, stop: 1 #cbdaf1);
 border: 1px solid #bfcde4;
}
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/styling-pyqt6-applications-default-and-custom-qss-stylesheets-3.PNG" alt="stylized pyqt6 application with custom qss stylesheet">
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to style PyQt6 Applications in Python. We've explored standard operating system styles, how to style them using inline code as well as how to create custom QSS Stylesheets.

David Landup

Marko Kosmajac

In this guide we'll take a look at how to style a PyQt application using the default and custom QSS stylesheets.

Styling PyQt6 Applications - Default and Custom QSS Stylesheets

Arpendu Kumar Garai

In this guide, we'll be taking a deep dive into how to invalidate JWT tokens when a user logs out of a Spring-based application, using Spring Security.

Spring Security: In-Memory Invalidation of JWT Tokens During User Logout

<h2 id="introduction">Introduction</h2>
Thymeleaf is a templating (server-side rendering) engine used by many Java software engineers within Spring-based web applications. An important feature of any web application is the support for dynamic URLs and path variables within those URLs.
Most REST APIs extensively use path variables to specify the IDs of elements they're performing operations on. For instance, a typical example would be:
<pre><code class="hljs">https://www.somewebsite.com/viewPost/path-variables-with-spring-boot
# OR
https://www.somewebsite.com/viewProduct/5
</code></pre>
In both of these cases, we're trying to find a resource denoted by a certain identifier. In the first case, we're identifying a resource by its title - <code>path-variables-with-spring-boot</code>, while in the second, we're identifying it through an incremental ID counter - <code>5</code>.

 <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: When using predictable path variables, such as an incremental counter, beware of security concerns. First of all - these are easily scrapeable, but most important than anything, without proper validation - someone might figure out that <code>/deleteProduct/5</code> deletes entries from the database, and decide to drop most of the entities stored within it.

 </div>
 </div>
 </div>
 In this guide - we'll take a look at how to leverage Thymeleaf to retrieve path variables, and how to use Spring Boot controllers to process them.
Throughout the guide, we'll be using a <code>Post</code> model, which represents a blog post - which just has an ID and some <code>content</code>:
<pre><code class="hljs">public class Post {

 @Id
 @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = &quot;post_sequence&quot;)
 private Long id;
 private String content;

 // Constructors, Getters, Setters, and toString 
}
</code></pre>
Since we're using Spring Boot - let's also bootstrap a <code>PostRepository</code> based on the <code>JpaRepository</code>, which allows us to perform CRUD operations out of the box:
<pre><code class="hljs">@Repository
public interface PostRepository extends JpaRepository&lt;Post, Long&gt; {}
</code></pre>
<h2 id="thymeleafpathvariableswithspringboot">Thymeleaf Path Variables with Spring Boot</h2>
Some URLs are dynamic - namely, given the fact that we can create, read, update and delete our <code>Post</code> entities, we'll want to have dynamic URLs for the <code>GET</code>, <code>UPDATE</code> and <code>DELETE</code> requests.
Let's initialize our project with a few artificial posts:
<pre><code class="hljs">@GetMapping(&quot;/initialize&quot;)
public ResponseEntity&lt;String&gt; initialize() {
 Post post1 = new Post(&quot;Content of post 1&quot;);
 Post post2 = new Post(&quot;Content of post 2&quot;);
 Post post3 = new Post(&quot;Content of post 3&quot;);
 postRepository.saveAll(List.of(post1, post2, post3));
 
 return ResponseEntity.ok(&quot;Initialized posts&quot;);
}
</code></pre>
Once we hit our <code>/initialize</code> endpoint, three posts will be generated and saved into the database. Now, let's define a static URL for the user to retrieve all posts:
<pre><code class="hljs">@GetMapping(&quot;/viewPosts&quot;)
public String viewAllPostsAndComments(Model model){
 List&lt;Post&gt; postList = postRepository.findAll();
 model.addAttribute(&quot;postList&quot;, postList);
 
 return &quot;all-posts&quot;;
}
</code></pre>
This is a static URL and handler - there aren't any path variables or parameters that can let the user influence which posts are being retrieved. This is typically what you want if you'd like to let the user choose where they'd like to navigate. Once chosen, they can view the detailed listing for any post, just by clicking on it and navigating to its page.
Since it'd be impractical (and unfeasible) to create a request handler for each post, we can make a dynamic handler that accepts any post ID, finds the post in the database and returns it:
<pre><code class="hljs">@GetMapping(&quot;/viewPost/{postId}&quot;)
public String viewPost(@PathVariable(&quot;postId&quot;) Long postId, Model model) {
 Post post = postRepository.findById(postId).get();
 model.addAttribute(&quot;post&quot;, post);
 
 return &quot;view-post&quot;;
}
</code></pre>
Here, we've defined a <code>@GetMapping</code> for the URL <code>/viewPost/{postId}</code>. The <code>postId</code> wrapped in curly brackets is a dynamic variable that can be set to any value and/or type. In our method's signature, we've used the <code>@PathVariable</code> annotation, setting the name of the path variable, and assigning it to a type that we can reference - <code>Long postId</code>.

 <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: The name of the path variable in the <code>@GetMapping</code> annotation has to match the name we've defined in the <code>@PathVariable</code> annotation. You can use as many path variables as you'd like in a URL, and match them via their names.

 </div>
 </div>
 </div>
 Once a <code>GET</code> request is fired on, say, the <code>/viewPost/5</code> endpoint - the <code>postId</code> is converted to a <code>Long</code> implicitly and we can use it to search for the post via its ID in the database. If we, however, pass in another type, such as a <code>String</code> - <code>/viewPost/some-post</code>, this controller will throw an exception:
<pre><code class="hljs">java.lang.NumberFormatException: For input string: &quot;some-post&quot;
</code></pre>
Since we've got the controllers to handle both a request to view all posts as well as to view a single one, let's quickly write up the Thymeleaf pages that allow us to navigate through to these request handlers. Let's first start off with a page that lists all of the posts and allows the user to navigate to the different controller request handlers:
<pre><code class="hljs">&lt;div th:each=&quot;post : ${postList}&quot;&gt;
 &lt;p th:text=&quot;${post.content}&quot;&gt;&lt;/p&gt;
 &lt;a class=&quot;btn btn-info&quot; th:href=&quot;@{/viewPost/{id}(id = ${post.id})}&quot;&gt;View Post&lt;/a&gt;
&lt;/div&gt;
</code></pre>
Here, we've iterated over each post in the <code>postList</code> (list of posts we've added to the <code>Model</code> instance) and for each one, added a button allowing the user to view the post. The <code>href</code> attribute of the link leads us to:
<pre><code class="hljs">th:href=&quot;@{/viewPost/{id}(id = ${post.id})}
</code></pre>
This is the <a rel="nofollow noopener" target="_blank" href="https://www.thymeleaf.org/doc/articles/standardurlsyntax.html">standard URL syntax</a> for adding parameters in Thymeleaf. The standard <code>@{}</code> expression used for links also accepts path variables. The <code>{id}</code> is a path variable, which we can externally set. Here, we've pointed it to the <code>post.id</code>. Once rendered on the server-side, this expression is evaluated as:
<pre><code class="hljs">&lt;a href=&quot;localhost:8080/viewPost/1&quot; class=&quot;btn btn-info&quot; &gt;View Post&lt;/a&gt;
</code></pre>
Clicking this button will trigger the <code>/viewPost/{postId}</code> endpoint, with the <code>postId</code> value being converted to <code>1</code> and the <code>postRepository</code> will fetch the post with the <code>id</code> of <code>1</code>, returning it to the <code>view-post</code> Thymeleaf view:
<pre><code class="hljs">&lt;div class=&quot;container&quot;&gt;
 &lt;div class=&quot;row&quot;&gt;
 &lt;div class=&quot;col-md-12 bg-light&quot;&gt;
 &lt;p th:text=&quot;${post.content}&quot;&gt;&lt;/p&gt;
 &lt;/div&gt;
 &lt;/div&gt;
&lt;/div&gt;
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Path variables are a common and key-feature of REST APIs. In this guide, we've taken a look at how to use path variables in Spring Boot with Thymeleaf.

Guest Contributor

In this guide, we'll be taking a look at how to use path variables in Spring Boot controllers, as well as how to generate links with path variables with Thymeleaf.

Thymeleaf Path Variables with Spring Boot

Accidentally committed something to the wrong branch? Perhaps, you just committed the new shining feature, and to your dismay, there's a typo in the user interface you haven't seen before, and you'd like to take the commit back to fix that as well?
In some cases, you can fix it, do another commit and then <a target="_blank" href="/git-squash-multiple-commits-in-to-one-commit">squash them together</a> before pushing to the remote repository, but only if you'll be pushing the change anyway.
Alternatively, you can undo the latest local commit, make additional changes, and then push that commit to the remote repository, if you wish so.
<h2 id="undolastlocalcommit">Undo Last Local Commit</h2>
Let's create a file we'd like to add to our repository, add it and finally commit:
<pre><code class="hljs">$ echo &quot;Hello World!&quot; &gt;&gt; file.txt
$ git add file.txt
$ git commit -m &quot;Added file.txt&quot;
$ echo &quot;It&#x27;s a great day today :(&quot; &gt;&gt; file.txt
$ git add file.txt
$ git commit -m &quot;Modified file.txt&quot;
</code></pre>
Yikes, we've accidentally left in a horrible typo in the content. We've put in the parentheses in the wrong way! And we've just committed that mistake:
<pre><code class="hljs">$ git log --pretty=oneline
df9fc1b773ecf3ba14c990615831f1087817611f (HEAD -&gt; main) Modified file.txt
55db4f399d1ad64e0a40e1858d23fef0ffe31fb0 Added file.txt
</code></pre>
To remove a local commit, assuming it hasn't been pushed to the remote repository yet, we can use the <code>git reset</code> command, which is effectively the opposite of <code>git add</code>:
<pre><code class="hljs">$ git reset HEAD~
Unstaged changes after reset:
M file.txt
</code></pre>
We've reset the <code>HEAD</code> (pointer to the last commit), pointing it back (<code>~</code>) to the previous commit. By including a number after the tilde, we could've gone back multiple commits instead of just one.

 <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: On certain operating systems, you might have to use different notation. <code>HEAD~</code>, <code>HEAD^</code> and <code>HEAD@{1}</code> all refer to the previous commit, but certain terminals and operating systems might not work with all of these notations.

 </div>
 </div>
 </div>
 Once reset, the change we've made to the <code>file.txt</code>, i.e. the erroneous modification is unstaged. Let's take a look at the log again:
<pre><code class="hljs">$ git log --pretty=oneline
55db4f399d1ad64e0a40e1858d23fef0ffe31fb0 (HEAD -&gt; main) Added file.txt
</code></pre>
And the status is:
<pre><code class="hljs">$ git status
On branch main
Changes not staged for commit:
 (use &quot;git add &lt;file&gt;...&quot; to update what will be committed)
 (use &quot;git restore &lt;file&gt;...&quot; to discard changes in working directory)
 modified: file.txt

no changes added to commit (use &quot;git add&quot; and/or &quot;git commit -a&quot;)
</code></pre>
However, what are the contents of the file now?
<pre><code class="hljs">$ nano file.txt

Hello World
It&#x27;s a great day today :(
</code></pre>
By default, the <code>reset</code> command is <code>--soft</code>. The <code>--soft</code> flag doesn't reset the changes done to the file, just removes the commit that was made. Let's go ahead and re-commit this mistake again, so we can take a look at what happens when we run the <code>--hard</code> option.
<h2 id="hardreset">Hard Reset</h2>
Instead of the <code>--soft reset</code>, which we can use to simply undo the commit, while leaving the files intact (and the changes still present, which is why the <code>git status</code> command prompted us with staging the changes) - we can also do a <code>--hard reset</code>:
<pre><code class="hljs">$ git reset --hard HEAD~
HEAD is now at 55db4f3 Added file.txt
</code></pre>
This time around, the changes aren't unstaged, like before. They're removed. If we check the <code>log</code>, it'll look much like last time:
<pre><code class="hljs">$ git log --pretty=oneline
55db4f399d1ad64e0a40e1858d23fef0ffe31fb0 (HEAD -&gt; main) Added file.txt
</code></pre>
Though, if we check the <code>status</code>:
<pre><code class="hljs">$ git status
On branch main
nothing to commit, working tree clean
</code></pre>
There's nothing to commit, because the change that was made to the file in the previous commit was also removed, setting the <code>HEAD</code> back to the first commit:
<pre><code class="hljs">$ nano file.txt
Hello World!
</code></pre>

In this short tutorial, we'll take a look at how to reset the HEAD in a Git repository - thereby undoing the latest local commit, and it's flavors.

Git: Undo Latest Local Commit

<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 turn off a Matplotlib plot's axis. That is to say - how to turn off individual elements, such as tick labels, grid, ticks and individual spines, but also how to turn them all off as a group, collectively referred to as the axis.
Most of the approaches we'll be covering work the same for 2D and 3D plots - both the regular <code>Axes</code> and <code>Axes3D</code> classes have the same methods for this. For some, since 3D plots have more than two spines, they won't be the same.

 <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 the remainder of this guide, we'll be using a 3D plot, as this is a more common case where you might want to turn off the spines and ticks - and let the data speak for itself, as well as a 2D plot on the same dataset.

 </div>
 </div>
 </div>
 We'll specifically be using a recreation of the CP1919 pulsar data, as discovered by <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Jocelyn_Bell_Burnell">Jocelyn Bell Burnell</a> in 1967, visualized by by Harold D. Craft, Jr. in his <a rel="nofollow noopener" target="_blank" href="https://www.worldcat.org/title/radio-observations-of-the-pulse-profiles-and-dispersion-measures-of-twelve-pulsars-by-harold-d-craft-jr/oclc/657635342">PhD Thesis in 1970</a> and popularized by <a rel="nofolllow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Peter_Saville_(graphic_designer)">Peter Saville</a> in 1979, when the English band Joy Division was on the lookout to release a new album - &quot;Unknown Pleasures&quot;:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

df = pd.read_csv(r&quot;https://raw.githubusercontent.com/StackAbuse/CP1919/master/data-raw/clean.csv&quot;)
groups = df.groupby([&#x27;line&#x27;])

plt.style.use(&#x27;dark_background&#x27;)

fig = plt.figure(figsize=(6, 8))

ax = fig.add_subplot(111, projection=&#x27;3d&#x27;)
ax.set_xlabel(&#x27;Line Number&#x27;)
ax.set_ylabel(&#x27;Time&#x27;)
ax.set_zlabel(&#x27;Intensity&#x27;)

for group in groups:
 line = ax.plot(group[1][&#x27;line&#x27;], group[1][&#x27;x&#x27;], group[1][&#x27;y&#x27;], color=&#x27;white&#x27;)

plt.show()
</code></pre>
Which results in:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-turn-off-axis-spines-ticklabels-axislabels-grid-1.png" alt="3D Ridge Plot in Matplotlib - CP1919">
<blockquote>
If you'd like to learn more about Ridge Plots (shown above), build a foundation in Matplotlib and explore advanced usage of the library, make sure to check out our <a href="https://gumroad.com/l/data-visualization-in-python-book-bundle" target="_blank">Data Visualization in Python eBoook Bundle</a>. This specific visualization is taken straight out of the book, from a longer section dedicated to this dataset and the history of the plot.
</blockquote>
Now, let's take a look at how to remove the spines, tick labels, ticks, grid and axis labels.
<h2 id="turningofftheaxiswithaxaxisoff">Turning off the Axis with ax.axis('off')</h2>
The easiest way to turn off everything axis-related is via a convenience function - <code>axis('off')</code> on your <code>Axes</code> or <code>Axes3D</code> instance:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Load dataset in and set style...

fig = plt.figure(figsize=(6, 8))

ax = fig.add_subplot(111, projection=&#x27;3d&#x27;)
ax.set_xlabel(&#x27;Line Number&#x27;)
ax.set_ylabel(&#x27;Time&#x27;)
ax.set_zlabel(&#x27;Intensity&#x27;)
ax.axis(&#x27;off&#x27;)

for group in groups:
 line = ax.plot(group[1][&#x27;line&#x27;], group[1][&#x27;x&#x27;], group[1][&#x27;y&#x27;], color=&#x27;white&#x27;)

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: You can also use the <code>axis('off')</code> function on the <code>plt</code> instance if you're plotting using the MATLAB-style API. Though, this approach is discouraged if you're plotting using the OOP API like we are currently.

 </div>
 </div>
 </div>
 This change to the code results in a plot without the spines, axis lines, ticks, tick labels, axis labels and grid:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-turn-off-axis-spines-ticklabels-axislabels-grid-2.png" alt="Turn axis off with axis('off')">
The <code>axis()</code> function is a convenience function to access various properties.
<h2 id="turningofftheaxiswithaxset_axis_off">Turning off the Axis with ax.set_axis_off()</h2>
Alternatively, you can use the <code>ax.set_axis_off()</code> function, in conjecture with the <code>ax.set_axis_on()</code> function, which reverses the former's effects.
This is a very useful set of functions to use when updating plots, such as when animating them, or whenever you might want to turn the axis off and on, rather than just disabling it:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Load dataset in and set style...

fig = plt.figure(figsize=(6, 8))

ax = fig.add_subplot(111, projection=&#x27;3d&#x27;)
ax.set_xlabel(&#x27;Line Number&#x27;)
ax.set_ylabel(&#x27;Time&#x27;)
ax.set_zlabel(&#x27;Intensity&#x27;)
ax.set_axis_off()

for group in groups:
 line = ax.plot(group[1][&#x27;line&#x27;], group[1][&#x27;x&#x27;], group[1][&#x27;y&#x27;], color=&#x27;white&#x27;)

plt.show()
</code></pre>
This results in the exact same plot:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-turn-off-axis-spines-ticklabels-axislabels-grid-3.png" alt="Turn axis off with set_axis_off()">
<h2 id="turningoffticksandticklabelsonaxes">Turning off Ticks and Tick Labels on Axes</h2>
Instead of turning all of these elements off, and making them invisible, you can also turn them off individually if you'd like to keep some.
This is where we'll be switching back to a 2D plot, since some of these functions don't work with 3D plots, given the fact that they've got more than just the X-axis and Y-axis.
For example, you can turn off individual axes (ticks and tick labels). You can use the <code>get_yaxis()</code> or <code>get_xaxis()</code> to get the respective axes and turn them off by using <code>set_visible(False)</code>:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv(r&quot;https://raw.githubusercontent.com/StackAbuse/CP1919/master/data-raw/clean.csv&quot;)
groups = df.groupby([&#x27;line&#x27;])

plt.style.use(&#x27;dark_background&#x27;)
fig = plt.figure(figsize=(6, 8))

ax = fig.add_subplot(111)
ax.set_xlabel(&#x27;Time&#x27;)
ax.set_ylabel(&#x27;Intensity&#x27;)

ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)

for group in groups:
 line = ax.plot(group[1][&#x27;x&#x27;], group[1][&#x27;y&#x27;], color=&#x27;white&#x27;)

plt.show()
</code></pre>
This turns off the tick labels and ticks themselves, but leaves the frame (spines) on:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-turn-off-axis-spines-ticklabels-axislabels-grid-4.png" alt="Turn ticks and tick labels off matplotlib">
<h2 id="turningoffindividualspinesonanaxes">Turning off Individual Spines on an Axes</h2>
To turn the spines off - you can access them via the <code>ax.spines</code> dictionary. Using their keys, <code>top</code>, <code>bottom</code>, <code>left</code>, and <code>right</code>, you can select each one, and using the <code>set_visible()</code> function, turn them off.
Let's turn of the top and right spine:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt

# Load data and stylize

fig = plt.figure(figsize=(6, 8))

ax = fig.add_subplot(111)
ax.set_xlabel(&#x27;Time&#x27;)
ax.set_ylabel(&#x27;Intensity&#x27;)

ax.spines[&#x27;right&#x27;].set_visible(False)
ax.spines[&#x27;top&#x27;].set_visible(False)
# To turn off the bottom or left
#ax.spines[&#x27;bottom&#x27;].set_visible(False)
#ax.spines[&#x27;left&#x27;].set_visible(False)

for group in groups:
 line = ax.plot(group[1][&#x27;x&#x27;], group[1][&#x27;y&#x27;], color=&#x27;white&#x27;)

plt.show()
</code></pre>
This turns off the top and right spine, but leaves the bottom and left intact - as well as the ticks and their labels:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-turn-off-axis-spines-ticklabels-axislabels-grid-5.png" alt="turn individual spines off in matplotlib">
You can also iterate through them, and turn them all off:
<pre><code class="hljs">for key, spine in ax.spines.items():
 spine.set_visible(False)
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/matplotlib-turn-off-axis-spines-ticklabels-axislabels-grid-6.png" alt="turn all spines off in matplotlib">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to turn off the axis, as well as individual axis components in Matplotlib.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 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 guide, we'll take a look at how to turn off the axis, as well as its constituent elements individually in Matplotlib.

Matplotlib: Turn Off Axis (Spines, Tick Labels, Axis Labels and Grid)

Aleksandar Bursac

In this guide, we'll introduce you to Cypress - an end-to-end JavaScript testing framework, and explore its pros and cons, creating a demonstration testing workflow.

End-to-End Testing in JavaScript with Cypress

<h2 id="introduction">Introduction</h2>
The in-memory data store - Redis is extensively used by developers as a database, cache layer, to manage job queues, and more.
It comes in handy when you are building APIs with a job queue mechanism to handle tasks like running memory-intensive jobs in the background, counting page visits, or sending bulk email campaigns.
If you are building an API in Python, the Redis Queue (RQ) module gives you functions to queue, schedule, and process these jobs by deploying workers.
In this article, you will be exploring the RQ module to set up job queues and workers, as well as the RQ-Dashboard module to visualize them.
<h2 id="settingupredis">Setting Up Redis</h2>
If you don't have an API already, or any code you can apply Redis RQ to - you can clone our <a target="_blank" href="https://github.com/StackAbuse/redis-queues-redis-queue-dashboards">GitHub repository</a> with sample code.
Let's clone the repo and install its dependencies:
<pre><code class="hljs">$ git clone git@github.com:StackAbuse/redis-queues-redis-queue-dashboards.git
$ cd redis-queues-redis-queue-dashboards
$ python -m venv env
$ . env/bin/activate
$ pip install -r requirements.txt
</code></pre>
We also have to install Redis, which can actually be a bit tricky if you're not using a Linux-based OS. The easiest way to install it on non-Linux operating systems is via <a href="https://docs.docker.com/compose/" target="_blank" rel="nofollow noopener">Docker Compose</a>:
<pre><code class="hljs">$ docker-compose up -d
</code></pre>
Our <code>docker-compose</code> file is configured to download a Redis image, and that command will run it in the background. Alternatively, you can install Redis locally.
For Ubuntu, that installation looks like this:
<pre><code class="hljs">$ sudo apt-get install redis
$ sudo service redis-server start
Starting redis-server: redis-server.
$ redis-cli -v 
redis-cli 4.0.9
</code></pre>
Now that our environment is created, let's take a look at Redis Queues.
<h2 id="redisqueuerq">Redis Queue (RQ)</h2>
The Redis Queue (RQ) is a queuing module that runs on top of Redis. It acts as the producer to submit the jobs to the queue. The module also comes with workers which act as consumers to process the submitted jobs from the queue asynchronously. But, what is a job anyway?
<blockquote>
Jobs are references to Python functions that are pushed to the queue.
</blockquote>
Multiple queues to process jobs can exist, and these queues can be named in any way you'd like. The jobs submitted to the queues can be monitored using their job IDs.
Let's write a simple script to enqueue a job in a Redis Queue, in say, <code>test.py</code>:
<pre><code class="hljs"># Imported to assign redis as the backend to rq
from redis import Redis
# Imported to initialize the queue object
from rq import Queue
# Functions from the __main__ module can&#x27;t be processed by workers
# Hence, we have a separate Python file containing the function
from test_job import i_am_a_job

# Create the queue object by passing in the redis object
q = Queue(connection=Redis())
 
# Run the job asynchronously
job = q.enqueue(i_am_a_job, 1)
# Return the function output
</code></pre>
The function which you want to enqueue has to be imported from a separate Python file. We've imported it from <code>test_job.py</code>:
<pre><code class="hljs"># A Function (or) a job
def i_am_a_job(arg1):
 # Perform some function
 return arg1
</code></pre>
Now that the Redis Queue and the function is set, let's execute the Python script:
<pre><code class="hljs">$ python test.py
</code></pre>
Running this command should create a job but return no output. If you get an error, review the setup steps again before continuing.
If everything worked, let's use RQ-Dashboard to manage our job.
<h2 id="managingredisqueuejobswithrqdashboard">Managing Redis Queue Jobs with RQ-Dashboard</h2>
You can inspect the state of your jobs in a Redis Queue by using RQ-Dashboard, a lightweight Flask app used to monitor Redis Queues. Let's run RQ-Dashboard to monitor the job we've just created.
In a separate Terminal, navigate to the folder where you cloned the repo. There, we'll spin up RQ-Dashboard:
<pre><code class="hljs">$ . env/bin/activate
$ rq-dashboard
RQ Dashboard version 0.5.2
 * Serving Flask app &#x27;rq_dashboard.cli&#x27; (lazy loading)
 * Environment: production
 WARNING: This is a development server. Do not use it in a production deployment.
 Use a production WSGI server instead.
 * Debug mode: off
 * Running on all addresses.
 WARNING: This is a development server. Do not use it in a production deployment.
 * Running on http://192.168.1.10:9181/ (Press CTRL+C to quit)
192.168.1.10 - - [11/Jun/2021 15:30:12] &quot;GET / HTTP/1.1&quot; 200 -
</code></pre>
You can access RQ-Dashboard at <a href="http://localhost:9181" target="_blank">http://localhost:9181</a>. When you open the link, you'll notice that your job is still in the queue and there aren't any workers assigned yet:
<img src="https://stackabuse.s3.amazonaws.com/media/redis-queues-redis-queue-dashboards-01.jpg" alt="Screenshot of RQ-Dashboard running for the first time, it has not workers and one job">
<h2 id="redisqueueworkers">Redis Queue Workers</h2>
Workers pick a job from the queue to execute them. In another Terminal (you can use the first as well), let's create a worker:
<pre><code class="hljs">$ . env/bin/activate # For new Terminals when you don&#x27;t install the dependencies locally
$ rq worker --with-scheduler
15:42:38 Worker rq:worker:a33eb6277eda4969921cc8e3f1e857c0: started, version 1.8.1
15:42:38 Subscribing to channel rq:pubsub:a33eb6277eda4969921cc8e3f1e857c0
15:42:38 *** Listening on default...
15:42:38 Trying to acquire locks for default
15:42:38 Cleaning registries for queue: default
15:42:38 Scheduler for default started with PID 1093
15:42:38 default: test_job.i_am_a_job(1) (b92bf928-48dd-4fb9-a551-427866c46a38)
15:42:38 default: Job OK (b92bf928-48dd-4fb9-a551-427866c46a38)
15:42:38 Result is kept for 500 seconds
</code></pre>
The job that you submitted has been executed and the result is kept in Redis for 500 seconds. In addition to the immediate job executions, jobs can also be scheduled to be run at a future time, similar to a <a href="/how-to-use-the-crontab-command-in-unix" target="_blank">CRON job</a>. The enqueue statement can be written as a scheduled one by:
<pre><code class="hljs">job = queue.enqueue_at(datetime(2021, 7, 7, 13, 15), i_am_a_job, 1)
</code></pre>
These operations are the basis of using Redis Queues, monitoring them and assigning workers. Now, let's write up a small, practical application that counts the number of page visits.
<h2 id="redisqueuedemoapplicationcountingsitevisits">Redis Queue Demo Application - Counting Site Visits</h2>
The code in the repository that you downloaded earlier includes a Flask application:
<pre><code class="hljs">from flask import Flask
from redis import Redis
from rq import Queue
from counter import visit

app = Flask(__name__)
q = Queue(connection=Redis())


@app.route(&#x27;/visit&#x27;)
def count_visit():
 count = q.enqueue(visit)
 return &quot;Visit has been registered&quot;


@app.route(&#x27;/&#x27;)
def return_visit_count():
 count = Redis().get(&#x27;count&#x27;).decode(&#x27;utf-8&#x27;) if Redis().get(&#x27;count&#x27;) else &#x27;0&#x27;
 return (f&#x27;&lt;h1&gt; Congrats! Your are the visitor no.: {count} &lt;/h1&gt;&#x27;)
</code></pre>
In your Terminal, let's run this Flask app:
<pre><code class="hljs">$ . env/bin/activate # Unless it&#x27;s already running
$ flask run
</code></pre>
This launches the Flask app in <code>app.py</code>. This app contains two routes: <code>/</code> and <code>/visit</code>.
Every time the <a href="http://localhost:5000/visit" target="_blank">http://localhost:5000/visit</a> endpoint is hit, the <code>count</code> key in Redis is incremented by 1 and the following webpage is returned.
<img src="https://stackabuse.s3.amazonaws.com/media/redis-queues-redis-queue-dashboards-02.jpg" alt="Screenshot of initial website visitor acknowledgement page">
The incrementing function is queued as a job. The number of visits is visible in the endpoint: <a href="http://localhost:5000" target="_blank">http://localhost:5000</a> as:
<img src="https://stackabuse.s3.amazonaws.com/media/redis-queues-redis-queue-dashboards-03.jpg" alt="Screenshot of website displaying the visitor count">
Let's try visiting the endpoint <a href="http://localhost:5000/visit" target="_blank">http://localhost:5000/visit</a> three times. This will submit our job thrice. Let's then check the status of our jobs on RQ-Dashboard. Visit <a href="http://localhost:9181" target="_blank">http://localhost:9181</a> and you can observe the following webpage where our jobs are successfully submitted but no workers are processing them:
<img src="https://stackabuse.s3.amazonaws.com/media/redis-queues-redis-queue-dashboards-04.jpg" alt="Screenshot of RQ-Dashboard showing new jobs being run">
To start the Redis Queue worker and scheduler, open another Terminal, and key in the command to start a worker. Observe that the submitted jobs are getting executed one after the other:
<pre><code class="hljs">$ . env/bin/activate # For new Terminals when you don&#x27;t install the dependencies locally
$ rq worker --with-scheduler
23:40:06 Worker rq:worker:f5a178b0931b42859699ce57696ed402: started, version 1.8.1
23:40:06 Subscribing to channel rq:pubsub:f5a178b0931b42859699ce57696ed402
23:40:06 *** Listening on default...
23:40:06 Trying to acquire locks for default
23:40:06 Cleaning registries for queue: default
23:40:06 Scheduler for default started with PID 2889
23:40:06 default: counter.visit() (d23c4df8-d638-476b-b70a-dbb4b6f091f2)
23:40:06 default: Job OK (d23c4df8-d638-476b-b70a-dbb4b6f091f2)
23:40:06 Result is kept for 500 seconds
23:40:06 default: counter.visit() (f4ca10c4-16f2-4578-b1b7-67dfce3cee5a)
23:40:06 default: Job OK (f4ca10c4-16f2-4578-b1b7-67dfce3cee5a)
23:40:06 Result is kept for 500 seconds
23:40:06 default: counter.visit() (956b7b39-0b82-4ac6-b29e-fe3f0706431e)
23:40:06 default: Job OK (956b7b39-0b82-4ac6-b29e-fe3f0706431e)
23:40:06 Result is kept for 500 seconds
</code></pre>
You can check the dashboard again and you may find that the jobs have been executed. This can be checked by pointing to the URL on your browser to <a href="http://localhost:9181" target="_blank">http://localhost:9181</a>. Notice that the worker is now up and running and the jobs have been processed successfully.
<img src="https://stackabuse.s3.amazonaws.com/media/redis-queues-redis-queue-dashboards-05.jpg" alt="Screenshot of RQ-Dashboard showing new working that's registered">
Let's check the number of visits by opening or refreshing the app on <a href="http://localhost:5000" target="_blank">http://localhost:5000</a>. Voilà! The page visit counter has been incremented by 3.
<img src="https://stackabuse.s3.amazonaws.com/media/redis-queues-redis-queue-dashboards-06.jpg" alt="Screenshot of visitor count website, the count was incremented by 3 since the last screenshot">
Think of a website with high traffic and one wishes to monitor the site visits and page visits. In this case, multiple instances of this API are served under a load balancer and the count is done based on the jobs submitted in the queue asynchronously.
<h2 id="conclusion">Conclusion</h2>
In this article, we have explored the importance of job queues and how RQ and RQ-Dashboards can serve as a minimalistic job queue stack to your web apps. The practical example can be expanded to other real-world applications where the possibilities are endless.

Marcus Sanatan

Sathiya Sarathi Gunasekaran

In this article, you will be exploring the RQ module to set up job queues and workers, as well as the RQ-Dashboard module to visualize them.

Redis Queues & Redis Queue Dashboards for Python API Development

<h3 id="introduction">Introduction</h3>
Counting sort is a sorting algorithm used to sort elements of an array in linear time. We usually use Counting Sort to sort integer arrays.
<blockquote>
Counting Sort is a stable, non-comparative algorithm.
</blockquote>
Non-comparative sorting algorithms perform sorting without any comparison between elements to be sorted.
Stable sorting algorithms preserve the relative order of elements with the same value in the sorted array. That means that the relative order of two same-value elements in the original array will be the same as their relative order in the sorted array.
<img src="https://i.postimg.cc/fwsYpzdf/radix-sort-in-python-01.png" alt="radix-sort-in-python-01.png">
Counting sort is not an in-place algorithm, it uses an auxiliary array to sort elements of an input array.
<h3 id="theideabehindthecountingsort">The Idea Behind the Counting Sort</h3>
Let's first take an intuitive look at how the algorithm works.
Assume that we have the array <code>I = [2, 2, 0, 6, 1, 9, 9, 7]</code> and we want to sort it. We'll call the array <code>I</code> the input array.
<blockquote>
Counting Sort works by counting the number of elements that fit a distinct key value, and then calculates the positions of each key.
</blockquote>
First of all, we need to find the element with the highest value, we'll call it the maximum element - <code>maxElement = 9</code>.
Then, we'll create an auxiliary array with <code>maxElement+1</code> elements, called the count array (C). We'll use it to store the number of occurrences of each individual element in the input array <code>I</code>. Therefore, all counts should be initialized to 0:
<pre><code class="hljs"> C = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] # Count array 
 # indices: 0 1 2 3 4 5 6 7 8 9
</code></pre>
Now, we need to go through the following steps:
1. Go over each element of the input array and increase its corresponding count by <code>1</code>
For example, if we come across an element with the value of <code>2</code> in the input array (<code>I</code>), we add 1 to the element with the index <code>2</code> in the count array:
<pre><code class="hljs"> I = [2, 2, 0, 6, 1, 9, 9, 7] # The first element is 2
 ^
 
 C = [0, 0, 1, 0, 0, 0, 0, 0, 0, 0] # We increase count of 2nd element by 1
#indices: 0 1 2 3 4 5 6 7 8 9
</code></pre>
After this step, the count array will store the number of occurrences of each element in the input array:
<pre><code class="hljs"> C = [1, 1, 2, 0, 0, 0, 1, 1, 0, 2] 
#indices: 0 1 2 3 4 5 6 7 8 9
 
# Element 0 has 1 occurrence
# Element 1 has 1 occurrence
# Element 2 has 2 occurrences 
# Element 3 has no occurrences...
</code></pre>
2. For each element in the count array, sum up its value with the value of all its previous elements, and store that value as the value of the current element:
<pre><code class="hljs"> C = [1, 2, 4, 4, 4, 4, 5, 6, 6, 8] 
#indices: 0 1 2 3 4 5 6 7 8 9
# Element 0 = 1
# Element 1 = 1 + 1
# Element 2 = 1 + 1 + 2
# Element 3 = 1 + 1 + 2 + 0
#...
</code></pre>
This way, we are storing the cumulative sum of the elements of the count array, on each step.
3. Calculate element position based on the count array values:
To store this sorted sequence, we'll need to create a new array. Let's call it the output array (<code>O</code>), and initialize it with <code>k</code> zeros, where <code>k</code> is the number of elements in the input array:
<pre><code class="hljs"> O = [0, 0, 0, 0, 0, 0, 0, 0] // Initialized output array
#indices: 0 1 2 3 4 5 6 7 
</code></pre>
For each element <code>I[i]</code> (starting from the end) in the input array:
<ol>
<li>Find the index in the count array that is equal to the value of the current element <code>I[i]</code>
<ul>
<li>That's the element <code>C[j]</code> where <code>j=I[i]</code></li>
</ul>
</li>
<li>Subtract <code>1</code> from the value of the <code>C[i]</code>
<ul>
<li>Now we have <code>newValue = C[i]-1</code></li>
</ul>
</li>
<li>Store the <code>I[i]</code> to the <code>O[newValue]</code></li>
<li>Update the <code>C[i]</code> with the <code>newValue</code></li>
</ol>
<img src="https://i.postimg.cc/C5GGyHXp/radix-sort-in-python-02.png" alt="radix-sort-in-python-02.png">
In the end, the output array contains the sorted elements of the input array!
<h3 id="howtoimplementcountingsortinpython">How to Implement Counting Sort in Python</h3>
Now, with all that out of the way - let's go ahead and implement Counting Sort in Python:
<pre><code class="hljs">def countingSort(inputArray):
 # Find the maximum element in the inputArray
 maxElement= max(inputArray)

 countArrayLength = maxElement+1

 # Initialize the countArray with (max+1) zeros
 countArray = [0] * countArrayLength

 # Step 1 -&gt; Traverse the inputArray and increase 
 # the corresponding count for every element by 1
 for el in inputArray: 
 countArray[el] += 1

 # Step 2 -&gt; For each element in the countArray, 
 # sum up its value with the value of the previous 
 # element, and then store that value 
 # as the value of the current element
 for i in range(1, countArrayLength):
 countArray[i] += countArray[i-1] 

 # Step 3 -&gt; Calculate element position
 # based on the countArray values
 outputArray = [0] * len(inputArray)
 i = len(inputArray) - 1
 while i &gt;= 0:
 currentEl = inputArray[i]
 countArray[currentEl] -= 1
 newPosition = countArray[currentEl]
 outputArray[newPosition] = currentEl
 i -= 1

 return outputArray

inputArray = [2,2,0,6,1,9,9,7]
print(&quot;Input array = &quot;, inputArray)

sortedArray = countingSort(inputArray)
print(&quot;Counting sort result = &quot;, sortedArray)
</code></pre>
Running the code above will produce the following output:
<pre><code class="hljs">Input array = [2, 2, 0, 6, 1, 9, 9, 7]
Counting sort result = [0, 1, 2, 2, 6, 7, 9, 9]
</code></pre>
<h3 id="thecomplexityofthecountingsortalgorithm">The Complexity of the Counting Sort Algorithm</h3>
The Counting sort algorithm uses only simple for and while loops without any complex recursions and subroutine calls, therefore, its complexity analysis is a pretty straightforward process.
Before we dive into the complexity analysis, let's label the length of the input array as <code>n</code> and the value of the maximum element in the input array as <code>k</code>.
<h4 id="timecomplexity">Time Complexity</h4>
The first step of the algorithm iterates over the input array n times in order to initialize the count array, so it has the complexity of O(n).
The second step iterates over the count k times in order to calculate the cumulative sum of each element, so it has the complexity of O(k).
The third step performs the sorting based on the counting array, so it has to iterate in a while loop <code>n</code> times, therefore it has the complexity of O(n).
Collectively, the time complexity of the Counting Sort algorithm is O(n+k).
<h4 id="spacecomplexity">Space Complexity</h4>
Counting sort uses input and output array, both of length <code>n</code> and one count array of length <code>(k+1)</code>.
Therefore, the total space that this algorithm uses is O(n+k).
<h3 id="conclusion">Conclusion</h3>
All in all, Counting Sort is a great and efficient, yet simple sorting algorithm. In ideal circumstances, it is really easy to understand and learn but still manages to maintain linear complexity.
The real problem occurs when the value of the largest element <code>k</code> exceeds the number of elements in the input array <code>n</code>. As the <code>k</code> approaches <code>n²</code>, the time complexity of the counting sort gets closer to O(n²), which is a horrible time complexity for a sorting algorithm. Therefore, it's not recommended to use counting sort if the input array has a large range of values.
Ideally, we will use Counting Sort to sort some integer arrays with a small range of values or as a subroutine for some other sorting algorithm, such as <a target="_blank" href="https://stackabuse.com/radix-sort-in-python">Radix Sort</a>. That way, we will ensure maximizing the full potential of the counting sort, while still avoiding all of the suboptimal use cases.

Dimitrije Stamenic

In this guide, we'll take a look at the theory behind Counting Sort and implement it in Python, as well as analyze its time and space complexity.

Counting Sort in Python

<h2 id="introduction">Introduction</h2>
In this article, we will take a look at how to check if an element is hidden with JQuery. Here are the most common ways to check the visibility of an element:
<pre><code class="hljs">console.log($(myElement).is(&quot;:hidden&quot;)) 
console.log($(myElement).is(&quot;:visible&quot;)) 
console.log($(myElement).css(&quot;visibility&quot;) === &quot;hidden&quot;) 
console.log($(myElement).css(&quot;display&quot;) === &quot;none&quot;) 
console.log($(myElement).css(&quot;opacity&quot;) &lt;= &quot;0&quot;) 
</code></pre>
<blockquote>
&quot;Why are there so many ways to check visibility?&quot;
</blockquote>
Multiple factors can play a role in the visibility of an element! We will cover each case and consider when it's wise to use them. Though, first, let's set up our test environment.
<h2 id="environmentsetup">Environment Setup</h2>
For this tutorial, we will use jQuery Core, version 3.6.0. You can get the latest CDN from <a href="https://code.jquery.com/" target="_blank" rel="nofollow noopener">jQuery's official website</a>.
Let's start by creating an <code>index.html</code> file with the boilerplate code most pages have, and add a <code>&lt;p&gt;</code> element with a class named <code>first-element</code> to the <code>&lt;body&gt;</code>:
<pre><code class="hljs">&lt;!DOCTYPE html&gt;
&lt;html lang=&quot;en&quot;&gt;

&lt;head&gt;
 &lt;meta charset=&quot;UTF-8&quot;&gt;
 &lt;meta http-equiv=&quot;X-UA-Compatible&quot; content=&quot;IE=edge&quot;&gt;
 &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width, initial-scale=1.0&quot;&gt;
 &lt;script src=&quot;https://code.jquery.com/jquery-3.6.0.min.js&quot;
 integrity=&quot;sha256-/xUj+3OJU5yExlq6GSYGSHk7tPXikynS7ogEvDej/m4=&quot; crossorigin=&quot;anonymous&quot;&gt;&lt;/script&gt;
 &lt;title&gt;Document&lt;/title&gt;
&lt;/head&gt;

&lt;body&gt;
 &lt;p class=&quot;first-element&quot; &gt;This is the first paragraph.&lt;/p&gt;
&lt;/body&gt;

&lt;/html&gt;
</code></pre>
Now let’s hide this paragraph, so that we can test its visibility with <code>.is(&quot;:hidden&quot;)</code>! To hide the <code>first-element</code> we can simply add <code>hidden</code> attribute to it:
<pre><code class="hljs">&lt;p class=&quot;first-element&quot; hidden&gt;This is the first paragraph&lt;/p&gt;
</code></pre>
Note: Reload the page and confirm that the <code>first-element</code> is no longer visible.
<h2 id="checkifelementishiddenwithishidden">Check if Element is Hidden with .is(&quot;:hidden&quot;)</h2>
To use <code>.is(&quot;:hidden&quot;)</code> you can either create <code>&lt;script&gt;&lt;/script&gt;</code> tags and add your JavaScript code within them, or use the Console tool of your browser to execute the code directly. Pick whichever you wish, it will not affect the outcome.
Either way, you can read the output from the Console tab (by pressing <code>F12</code> or <code>Ctrl + Shift + I</code> for most browsers). Alternatively, you can right-click on the page and select &quot;Inspect&quot; from the menu. In Firefox it's &quot;Inspect element&quot;.
<code>.is(&quot;:hidden&quot;)</code> will return <code>true</code> if the selected element is hidden. If it's not hidden, then it will return <code>false</code>.
Let's use this method on our hidden <code>.first-element</code>:
<pre><code class="hljs">var myElement = &quot;.first-element&quot;;
console.log(myElement + &quot; is hidden?: &quot; + $(myElement).is(&quot;:hidden&quot;));
</code></pre>
If you check the Console tab of your browser, you should see the following output:
<pre><code class="hljs">.first-element is hidden?: true
</code></pre>
Fairly simple, right? We can use the method <code>is(&quot;:visible&quot;)</code> to verify our current result.
<h2 id="checkifelementishiddenwithisvisible">Check if Element is Hidden with is(&quot;:visible&quot;)</h2>
<code>is(&quot;:visible&quot;)</code> will test the visibility of an element and will return <code>true</code> if the selected element is visible, or it will return <code>false</code> if it is hidden.
As you've noticed, it is the direct opposite of the <code>.is(&quot;:hidden&quot;)</code> method. This means that both of them can’t return the same value for the same element. Not at the same time at least.
Let's test it on the <code>first-element</code> and observe the result:
<pre><code class="hljs">var myElement = &quot;.first-element&quot;;
console.log(myElement + &quot; is visible?: &quot; + $(myElement).is(&quot;:visible&quot;));
</code></pre>
As expected, it will output a <code>false</code> value:
<pre><code class="hljs">.first-element is visible?: false
</code></pre>
Note that you would also get the same results when working with the hidden inputs:
<pre><code class="hljs">&lt;input type=&quot;hidden&quot; class=&quot;inp-element&quot; value=&quot;3487&quot;&gt;
</code></pre>
Although the <code>hidden</code> parameter passed into our <code>input</code> element via the <code>type</code> attribute, it still produces the same result.
So far so good. Now let's take our game one step forward and see how to test visibility that has been modified by the CSS.
<h2 id="checkifelementishiddenwithcssvisibility">Check if Element is Hidden with .css(&quot;visibility&quot;)</h2>
Let's add two more items into our DOM:
<pre><code class="hljs">&lt;p class=&quot;second-element&quot;&gt;This is the second paragraph.&lt;/p&gt;
&lt;p class=&quot;third-element&quot;&gt;This is the third paragraph.&lt;/p&gt;
</code></pre>
Refresh/reload your page and confirm that new elements are added.
Now we will change the <code>visibility</code> property of the <code>second-element</code>. To do so, you can create a CSS file and link it to your HTML file or write your CSS code inside the <code>&lt;head&gt;</code> tag of your HTML file, inside the <code>&lt;style&gt;&lt;/style&gt;</code> tags:
<pre><code class="hljs">.second-element{
 visibility: hidden; 
}
</code></pre>
Now this part is a bit tricky. Before reloading the page, take a good look at the current position of the <code>third-element</code>. If you refresh the page, you will notice that the <code>second-element</code> is not visible anymore, but it still takes up the same space. It is not visible, yet the position of the <code>third-element</code> implies that it's still there. In fact, if we go ahead and run our previous functions for this element:
<pre><code class="hljs">var myElement = &quot;.second-element&quot;;
console.log(myElement + &quot; is hidden?: &quot; + $(myElement).is(&quot;:hidden&quot;));
console.log(myElement + &quot; is visible?: &quot; + $(myElement).is(&quot;:visible&quot;));
</code></pre>
We would get the result that it is not hidden, but it still is visible:
<pre><code class="hljs">.second-element is hidden?: false
.second-element is visible?: true
</code></pre>
The reason is that when you set the <code>visibility</code> property to <code>hidden</code>, it becomes invisible but it is still rendered by the browser, so it takes up its initial space. Most browsers consider elements visible if it has <code>height</code> and/or <code>width</code>. In other words, any element with zero dimensions is considered hidden.
Now that we know what we're dealing with, all we have to do is to check if <code>visibility</code> property of the element is set to <code>hidden</code>, not whether the element itself is <code>hidden</code>:
<pre><code class="hljs">var myElement = &quot;.second-element&quot;;
console.log(myElement + &quot; is visibility === hidden?: &quot; + ($(myElement).css(&quot;visibility&quot;) === &quot;hidden&quot;));
</code></pre>
This will return <code>true</code>:
<pre><code class="hljs">.second-element is visibility === hidden?: true
</code></pre>
While we're at it, let's work out what other CSS properties affect the visibility.
<h2 id="checkifelementishiddenwithcssdisplay">Check if Element is Hidden with .css(&quot;display&quot;)</h2>
Another CSS property that is commonly used to hide elements is <code>display</code>. We already have our <code>third-element</code> ready in our DOM. So all we have to do is set its <code>display</code> to <code>none</code>:
<pre><code class="hljs">.third-element {
 display: none; 
}
</code></pre>
Upon refreshing the page, you can see that it is not visible anymore.
Now, the good thing about <code>display: none;</code> is that we can select it correctly by using our previous <code>is(&quot;:hidden&quot;)</code> and <code>is(&quot;:visible&quot;)</code> methods:
<pre><code class="hljs">var myElement = &quot;.third-element&quot;;
console.log(myElement + &quot; is hidden?: &quot; + $(myElement).is(&quot;:hidden&quot;));
console.log(myElement + &quot; is visible?: &quot; + $(myElement).is(&quot;:visible&quot;));
</code></pre>
Since the browser doesn't render the <code>third-element</code>, we get the results as expected:
<pre><code class="hljs">.third-element is hidden?: true
.third-element is visible?: false
</code></pre>
We can also select it with using the <code>.css()</code> selector:
<pre><code class="hljs">var myElement = &quot;.third-element&quot;;
console.log(myElement + &quot; is css.display == none?: &quot; + ($(myElement).css(&quot;display&quot;) === &quot;none&quot;));
</code></pre>
And we would get the following output as a result:
<pre><code class="hljs">.third-element is css.display == none?: true
</code></pre>
Another way to make an element invisible is to set its opacity to zero. In the next section, we will create a new element, change its opacity, and check whether it's visible or not.
<h2 id="checkifelementishiddenwithcssopacity">Check if Element is Hidden with .css(&quot;opacity&quot;)</h2>
Making an item invisible via opacity behaves similarly to setting the <code>visibility</code> property to <code>hidden</code>. For this reason, we will add two more elements to observe the change better:
<pre><code class="hljs">&lt;p class=&quot;fourth-element&quot;&gt;This is the fourth paragraph.&lt;/p&gt;
&lt;p class=&quot;visible-element&quot;&gt;Lorem ipsum dolor sit amet consectetur adipisicing elit. Quis corrupti inventore, et beatae accusantium perferendis?&lt;/p&gt;
</code></pre>
Now let's add some padding to emphasize the space taken by the <code>fourth-element</code>, and also set it's opacity to zero:
<pre><code class="hljs">.fourth-element {
 padding: 30px;
 opacity: 0;
}
</code></pre>
Refreshing the page, you will notice the absence of the <code>fourth-element</code>. It has dimensions, thus it's rendered, but it is not opaque, so it is not visible.
So naturally, all the following methods:
<pre><code class="hljs">var myElement = &quot;.fourth-element&quot;;
console.log(myElement + &quot; is hidden?: &quot; + $(myElement).is(&quot;:hidden&quot;));
console.log(myElement + &quot; is visibility === hidden?: &quot; + ($(myElement).css(&quot;visibility&quot;) === &quot;hidden&quot;));
console.log(myElement + &quot; is css.display == none?: &quot; + ($(myElement).css(&quot;display&quot;) === &quot;none&quot;));
</code></pre>
Will return <code>false</code>:
<pre><code class="hljs">.fourth-element is hidden?: false
.fourth-element is visibility === hidden?: false
.fourth-element is css.display == none?: false
</code></pre>
The only way to catch this invisible element, is to use the <code>.css(&quot;opacity&quot;)</code> selector:
<pre><code class="hljs">var myElement = &quot;.fourth-element&quot;;
console.log(myElement + &quot; is opacity lesser than or equal to 0?: &quot; + ($(myElement).css(&quot;opacity&quot;) &lt;= &quot;0&quot;));
</code></pre>
This returns <code>true</code>:
<pre><code class="hljs">.fourth-element is opacity lesser than or equal to 0?: true
</code></pre>
And this concludes our tutorial on how to check if an element is hidden with jQuery!
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we learned how to check the visibility of an element using jQuery selectors. While the <code>.is(&quot;:hidden&quot;)</code>, <code>is(&quot;:visible&quot;)</code>, and <code>.css(&quot;display&quot;)</code> selectors are good choice to select the non-rendered elements, <code>.css(&quot;visibility&quot;)</code> and <code>.css(&quot;opacity&quot;)</code> are the best fits for the elements that are rendered but not visible to human eyes.

Ruslan Hasanov

An element in HTML can be hidden through different properties, attributes and CSS configurations. In this article, we'll use jQuery to determine if an element is hidden.