<h2 id="introduction">Introduction</h2>
Code Delaying (also known as sleeping) is exactly what the name implies, the delaying of code execution for some amount of time. The most common need for code delaying is when we're waiting for some other process to finish, so that we can work with the result of that process. In multi-threaded systems, a thread might want to wait for another thread to finish an operation, to continue working with that result.
Another example could be lessening the strain on a server we're working with. For example, while web scraping (ethically), and following the ToS of the website in question, abiding by the <code>robots.txt</code> file - you might very well want to delay the execution of each request so as to not overwhelm the resources of the server.
Many requests, fired in rapid succession can, depending on the server in question, quickly take up all of the free connections and effectively become a DoS Attack. To allow for breathing space, as well as to make sure we don't negatively impact either the users of the website or the website itself - we'd limit the number of requests sent by delaying each one.
A student, waiting for exam results might furiously refresh their school's website, waiting for news. Alternatively, they might write a script that checks if the website has anything new on it. In a sense, code delay can technically become code scheduling with a valid loop and termination condition - assuming that the delay mechanism in place isn't blocking.
In this article, we'll take a look at how to delay code execution in Python - also known as sleeping.
<h2 id="delayingcodewithtimesleep">Delaying Code with time.sleep()</h2>
One of the most common solutions to the problem is the <code>sleep()</code> function of the built-in <code>time</code> module. It accepts the number of seconds you'd like the process to sleep for - unlike many other languages that are based in milliseconds:
<pre><code class="hljs">import datetime
import time

print(datetime.datetime.now().time())
time.sleep(5)
print(datetime.datetime.now().time())
</code></pre>
This results in:
<pre><code class="hljs">14:33:55.282626
14:34:00.287661
</code></pre>
Quite clearly, we can see a 5s delay between the two <code>print()</code> statements, with a fairly high precision - down to the second decimal place. If you'd like to sleep for less than 1 second, you can easily pass non-whole numbers as well:
<pre><code class="hljs">print(datetime.datetime.now().time())
time.sleep(0.25)
print(datetime.datetime.now().time())
</code></pre>
<pre><code class="hljs">14:46:16.198404
14:46:16.448840
</code></pre>
<pre><code class="hljs">print(datetime.datetime.now().time())
time.sleep(1.28)
print(datetime.datetime.now().time())
</code></pre>
<pre><code class="hljs">14:46:16.448911
14:46:17.730291
</code></pre>
Though, keep in mind that with 2 decimal places, the sleep duration might not be exactly on spot, especially since it's hard to test, given the fact that the <code>print()</code> statements take some (variable) time to execute as well.
However, there's one major downside to the <code>time.sleep()</code> function, very noticeable in multi-threaded environments.
<blockquote>
time.sleep() is blocking.
</blockquote>
It seizes up the thread it's on and blocks it for the duration of the sleep. This makes it unfit for longer waiting times, as it clogs up the thread of the processor during that time period. Additionally, this make it unfit for Asynchronous and Reactive Applications, which oftentimes require real-time data and feedback.
Another thing to note about <code>time.sleep()</code> is the fact that you can't stop it. Once it starts, you can't externally cancel it without terminating the entire program or if you cause the <code>sleep()</code> method itself to throw an exception, which would halt it.
<h2 id="asynchronousandreactiveprogramming">Asynchronous and Reactive Programming</h2>
<blockquote>
Asynchronous Programming revolves around parallel execution - where a task can be executed and finished independent of the main flow.
</blockquote>
In Synchronous Programming - if a Function A calls Function B, it stops execution until Function B finishes execution, after which Function A can resume.
In Asynchronous Programming - if a Function A calls Function B, regardless of its dependence of the result from Function B, both can execute at the same time, and if need be, wait for the other one to finish to utilize each other's results.
<a rel="nofollow noopener" target="_blank" href="https://www.reactivemanifesto.org/">Reactive Programming</a> is a subset of Asynchronous Programming, which triggers code execution reactively, when data is presented, regardless of whether the function supposed to process it is already busy. Reactive Programming relies heavily on Message-Driven Architectures (where a message is typically an event or a command).
Both Asynchronous and Reactive applications are the ones that suffer greatly from blocking code - so using something like <code>time.sleep()</code> isn't a good fit for them. Let's take a look at some non-blocking code delay options.
<h2 id="delayingcodewithasynciosleep">Delaying Code with asyncio.sleep()</h2>
Asyncio is a Python library dedicated to writing concurrent code, and uses the <code>async</code>/<code>await</code> syntax, which might be familiar to developers who have used it in other languages.
Let's install the module via <code>pip</code>:
<pre><code class="hljs">$ pip install asyncio
</code></pre>
Once installed, we can <code>import</code> it into our script and rewrite our function:
<pre><code class="hljs">import asyncio
async def main():
 print(datetime.datetime.now().time())
 await asyncio.sleep(5)
 print(datetime.datetime.now().time())

asyncio.run(main())
</code></pre>
When working with <code>asyncio</code>, we mark functions that run asynchronously as <code>async</code>, and <code>await</code> the results of operations such as <code>asyncio.sleep()</code> that will be finished at some point in the future.
Similar to the previous example, this will print two times, 5 seconds apart:
<pre><code class="hljs">17:23:33.708372
17:23:38.716501
</code></pre>
Though, this doesn't really illustrate the advantage of using <code>asyncio.sleep()</code>. Let's rewrite the example to run a few tasks in parallel, where this distinction is a lot more clear:
<pre><code class="hljs">import asyncio
import datetime

async def intense_task(id):
 await asyncio.sleep(5)
 print(id, &#x27;Running some labor-intensive task at &#x27;, datetime.datetime.now().time())

async def main():
 await asyncio.gather(
 asyncio.create_task(intense_task(1)),
 asyncio.create_task(intense_task(2)),
 asyncio.create_task(intense_task(3))
 )

asyncio.run(main())
</code></pre>
Here, we've got an <code>async</code> function, which simulates a labor-intensive task that takes 5 seconds to finish. Then, using <code>asyncio</code>, we create multiple tasks. Each task can run asynchronously, though, only if we call them asynchronously. If we were to run them sequentially, they'd also execute sequentially.
To call them in parallel, we use the <code>gather()</code> function, which, well, gathers the tasks and executes them:
<pre><code class="hljs">1 Running some labor-intensive task at 17:35:21.068469
2 Running some labor-intensive task at 17:35:21.068469
3 Running some labor-intensive task at 17:35:21.068469
</code></pre>
These are all executed at the same time, and the waiting time for the three of them isn't 15 seconds - it's 5.
On the other hand, if we were to tweak this code to use <code>time.sleep()</code> instead:
<pre><code class="hljs">import asyncio
import datetime
import time

async def intense_task(id):
 time.sleep(5)
 print(id, &#x27;Running some labor-intensive task at &#x27;, datetime.datetime.now().time())

async def main():
 await asyncio.gather(
 asyncio.create_task(intense_task(1)),
 asyncio.create_task(intense_task(2)),
 asyncio.create_task(intense_task(3))
 )

asyncio.run(main())
</code></pre>
We'd be waiting for 5 seconds between each <code>print()</code> statement:
<pre><code class="hljs">1 Running some labor-intensive task at 17:39:00.766275
2 Running some labor-intensive task at 17:39:05.773471
3 Running some labor-intensive task at 17:39:10.784743
</code></pre>
<h2 id="delayingcodewithtimer">Delaying Code with Timer</h2>
The <code>Timer</code> class is a <code>Thread</code>, that can run and execute operations only after a certain time period has passed. This behavior is exactly what we're looking for, though, it's a bit of an overkill to use <code>Thread</code>s to delay code if you're not already working with a multi-threaded system.
The <code>Timer</code> class needs to <code>start()</code>, and can be halted via <code>cancel()</code>. Its constructor accepts an integer, denoting the number of seconds to wait before executing the second parameter - a function.
Let's make a function and execute it via a <code>Timer</code>:
<pre><code class="hljs">from threading import Timer
import datetime

def f():
 print(&quot;Code to be executed after a delay at:&quot;, datetime.datetime.now().time())

print(&quot;Code to be executed immediately at:&quot;, datetime.datetime.now().time())
timer = Timer(3, f)
timer.start()
</code></pre>
This results in:
<pre><code class="hljs">Code to be executed immediately at: 19:47:20.032525
Code to be executed after a delay at: 19:47:23.036206
</code></pre>
The <code>cancel()</code> method comes in really handy if we have multiple functions running, and we'd like to cancel the execution of a function, based on the results of another, or on another condition.
Let's write a function <code>f()</code>, which calls on both <code>f2()</code> and <code>f3()</code>. <code>f2()</code> is called as-is - and returns a random integer between 1 and 10, simulating the time it took to run that function.
<code>f3()</code> is called through a <code>Timer</code> and if the result of <code>f2()</code> is greater than <code>5</code>, <code>f3()</code> is canceled, whereas if <code>f2()</code> runs in the &quot;expected&quot; time of less than <code>5</code> - <code>f3()</code> runs after the timer ends:
<pre><code class="hljs">from threading import Timer
import datetime
import random

def f():
 print(&quot;Executing f1 at&quot;, datetime.datetime.now().time())
 result = f2()
 timer = Timer(5, f3)
 timer.start()
 if (result &gt; 5):
 print(&quot;Canceling f3 since f2 resulted in&quot;, result)
 timer.cancel()

def f2():
 print(&quot;Executing f2 at&quot;, datetime.datetime.now().time())
 return random.randint(1, 10)

def f3():
 print(&quot;Executing f3 at&quot;, datetime.datetime.now().time())

f()
</code></pre>
Running this code multiple times would look something along the lines of:
<pre><code class="hljs">Executing f1 at 20:29:10.709578
Executing f2 at 20:29:10.709578
Canceling f3 since f2 resulted in 9

Executing f1 at 20:29:14.178362
Executing f2 at 20:29:14.178362
Executing f3 at 20:29:19.182505
</code></pre>
<h2 id="delayingcodewithevent">Delaying Code with Event</h2>
The <code>Event</code> class can be used to generate events. A single event can be &quot;listened to&quot; by multiple threads. The <code>Event.wait()</code> function blocks the thread it's on, unless the <code>Event.isSet()</code>. Once you <code>set()</code> an Event, all the threads that waited are awoken and the <code>Event.wait()</code> becomes non-blocking.
This can be used to synchronize threads - all of them pile up and <code>wait()</code> until a certain Event is set, after which, they can dictate their flow.
Let's create a <code>waiter</code> method and run it multiple times on different threads. Each waiter starts working at a certain time and checks if they're still on the hour every second, right before they take an order, which takes a second to fulfill. They'll be working until the Event is set - or rather, their working time is up.
Each waiter will have their own thread, while management resides in the main thread, and call when everyone can call home. Since they're feeling extra generous today, they'll cut the working time and let the waiters go home after 4 seconds of work:
<pre><code class="hljs">import threading
import time
import datetime

def waiter(event, id):
 print(id, &quot;Waiter started working at&quot;, datetime.datetime.now().time())
 event_flag = end_of_work.wait(1)
 while not end_of_work.isSet():
 print(id, &quot;Waiter is taking order at&quot;, datetime.datetime.now().time())
 event.wait(1)
 if event_flag:
 print(id, &quot;Waiter is going home at&quot;, datetime.datetime.now().time())

end_of_work = threading.Event()

for id in range(1, 3):
 thread = threading.Thread(target=waiter, args=(end_of_work, id))
 thread.start()

end_of_work.wait(4)
end_of_work.set()
print(&quot;Some time passed, management was nice and cut the working hours short. It is now&quot;, datetime.datetime.now().time())
</code></pre>
Running this code results in:
<pre><code class="hljs">1 Waiter started working at 23:20:34.294844
2 Waiter started working at 23:20:34.295844
1 Waiter is taking order at 23:20:35.307072
2 Waiter is taking order at 23:20:35.307072
1 Waiter is taking order at 23:20:36.320314
2 Waiter is taking order at 23:20:36.320314
1 Waiter is taking order at 23:20:37.327528
2 Waiter is taking order at 23:20:37.327528
Some time passed, management was nice and cut the working hours short. It is now 23:20:38.310763
</code></pre>
The <code>end_of_work</code> event was used here to sync up the two threads and control when they work and when not to, delaying the code execution by a set time between the checks.
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at several ways to delay code execution in Python - each applicable to a different context and requirement.
The regular <code>time.sleep()</code> method is pretty useful for most applications, though, it's not really optimal for long waiting times, isn't commonly used for simple scheduling and is blocking.
Using <code>asyncio</code>, we've got an asynchronous version of <code>time.sleep()</code> that we can <code>await</code>.
The <code>Timer</code> class delays code execution and can be canceled if need be.
The <code>Event</code> class generates events that multiple threads can listen to and respond accordingly, delaying code execution until a certain event is set.

David Landup

Lazar Ristic

In this guide, we'll be taking a look at how to delay code execution/make a time delay/sleep in Python, for both synchronous and asynchronous code with examples.

Python: Make Time Delay (Sleep) for Code Execution

<h2 id="introduction">Introduction</h2>
The digital revolution has changed our lives in many ways. Nowadays, our picture albums, music collections, bookshelves etc. are all digital - binaries written on a disk. Our life and work are shared between a multitude of devices. Companies have development, staging, testing areas and dozens of developers connected to them.
From this shift in our life dynamics emerged two problems: how to preserve the integrity of our data and how to make it synchronized across all of our devices? Enter rsync, a tool that aims and actually succeeds in solving those issues.
First released in 1996 under the <a rel="nofollow noopener" target="_blank" href="https://www.gnu.org/licenses/gpl-3.0.html">GPLv3</a> license, rsync is an open-source file transfer and synchronization tool written in C. It works by comparing sizes and modification times (<code>mtime</code>) to decide which files need to be synchronized, and uses an effective algorithm to minimize network bandwidth for transfers.
Following the <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Unix_philosophy">Unix philosophy</a>, rsync is very lightweight, easily configurable and scriptable. It has reached great popularity and ubiquity. Pretty much every Linux Distribution comes with rsync preinstalled; you can even find it on MacOS out of the box!
Of course, it can be built from source as well - the tarball can be found <a rel="nofollow noopener" target="_blank" href="https://rsync.samba.org/">here</a>. For Windows users though, some additional effort is required. It can be used with the Cygwin runtime, or under WSL.
<h2 id="basicrsyncoperations">Basic rsync Operations</h2>
<pre><code class="hljs">$ rsync options source destination
</code></pre>
The syntax is pretty straightforward. You call <code>rsync</code>, list the options and choose the source and destination. All options can be found in rsync's <code>man</code> pages. Let's take a look at the key options we'll be using:
<ul>
<li>
<code>--archive</code> or <code>-a</code> 
This option is an alias for <code>-rlptgoD</code> which boils down to - do a recursive call trying to preserve as much as you can. This includes <code>mtime</code>, permissions and ownership, symlinks, etc. This option is almost always used. Hard Links are not included since tracking them down can be a costly operation. They can be explicitly requested with the <code>-H</code> option.
</li>
<li>
<code>--verbose</code> or <code>-v</code> and <code>--human-readable</code> or <code>h</code>. 
This option, very common with command line programs, forces rsync to log the operations it performs to the standard output stream. Should be skipped in scripts, where the <code>--quiet</code> or <code>-q</code> option is preferred as it produces no output.
</li>
<li>
<code>--compress</code> or <code>-z</code> 
This option uses compression during network transfer to reduce bandwidth. Very desirable and almost always used; same as the <code>--archive</code> option.
</li>
<li>
<code>--dry-run</code> or <code>-n</code> 
This tells rsync to simulate the process and tell us what will be updated or deleted without actually doing anything. Useful for double checking our arguments and dealing with sensitive data.
</li>
<li>
<code>--update</code> or <code>-u</code> 
This option tells rsync to skip files that are newer in the destination than in the source. We will take a deeper look at its effects in the examples below.
</li>
<li>
<code>--del</code> 
This option tells rsync to delete all files in the destination not included in the source argument. Useful for cleaning up temporary files which we don't need anymore but backed up during previous synchronization.
</li>
<li>
<code>--inplace</code> 
The default way rsync works is by copying new files over, and then deleting the data it's substituting. This option tells it to substitute data in-place which doesn't take that much storage in the transfer process. Useful in situations without much storage headroom ie. transfering to a flash drive etc.
</li>
</ul>
<h2 id="rsyncexamples">rsync Examples</h2>
<pre><code class="hljs">$ rsync -avz src dest
</code></pre>
This is the most common way you'll be invoking <code>rsync</code>. Preserve and compress everything, while logging the operations.
For remote locations:
<pre><code class="hljs">$ rsync -avz src user@destination:location
</code></pre>
If you have an external hard disk you'd like to sync the files on - but use two devices to edit them (say, editing photos on a laptop and desktop), the <code>-u</code> flag comes in handy as you might not want <code>rsync</code> to override the more recent work on either of these with their old versions:
<pre><code class="hljs">$ rsync -avuz src /mnt/my_hdd
</code></pre>
<h2 id="rsyncwithremotehosts">rsync with Remote Hosts</h2>
Another thing rsync has going for it the fact that it excels with remote transfers. Using <code>ssh</code> by default (there are other protocols available, it even has its own), it is fully integrated with ssh keyrings. The only caveat is that rsync needs to be installed on both ends, but with such ubiquity, that is almost never an issue.
<h2 id="performingafullsystembackup">Performing a Full System Backup</h2>
Full system backups are common with many *nix users, if they are either particularly worried with their data, or just like experimenting and having a fail safe. We will be using some additional options like <code>-A</code> and <code>-X</code> which preserve ACLs and extended attributes. Some file trees on our file system are unnecessary, so we will be excluding them with the <code>--exclude</code> option. We will also remove any residual file which we have locally removed between the two backups:
<pre><code class="hljs">$ sudo rsync -aAXv --del --exclude={&quot;/dev/*&quot;, &quot;/proc/*&quot;, &quot;/sys/*&quot;, &quot;/tmp/*&quot;, &quot;/run/*&quot;, &quot;/mnt/*&quot;, &quot;/media/*&quot;,&quot;/lost+found&quot;} dest
</code></pre>
<h2 id="dailybackupswithrsyncandcrontab">Daily Backups with rsync and crontab</h2>
Using <a target="_blank" href="/how-to-use-the-crontab-command-in-unix/"><code>crontab</code></a>, we can schedule daily, weekly, monthly or even variable time backups. Let's write a <code>cron</code> expression and schedule our <code>rsync</code> command to run every day at <code>00:00</code>:
<pre><code class="hljs">0 0 * * * root sudo rsync -aAXv --del --exclude={&quot;/dev/*&quot;, &quot;/proc/*&quot;, &quot;/sys/*&quot;, &quot;/tmp/*&quot;, &quot;/run/*&quot;, &quot;/mnt/*&quot;, &quot;/media/*&quot;,&quot;/lost+found&quot;} dest
</code></pre>
In your <code>/etc</code> directory, you can find multiple <code>cron.*</code> directories, corresponding to how often their contents should be checked and run. To create a daily backup of our entire system we can take the above command, place it in a file called, let's say, <code>daily_backup.sh</code> and place it inside <code>/etc/cron.daily/</code>.
This command will run at a specific time, defined by your <code>crontab</code>. Make sure your script is executable and starts with a defining shebang.
<h2 id="conclusion">Conclusion</h2>
What's not to like? A minimal and lightweight command line tool, that is simple to use, able to do a lot of things, easy to put into scripts, and does what it does pretty fast. It's no surprise rsync reached such broad popularity and availability. It does a pretty good job at this one thing everyone, aware of that or not, actually needs.

Dragan Bjekic

In this guide, we'll take a look at examples on how to use the rsync command to sync files, folders and schedule backups in fixed time intervals, on Unix/Linux/MacOS.

How to Use the Rsync Command in Unix

In this guide, we'll take a look at how to call a Python Flask Microservice from a Spring Boot Microservice, using Netflix Eureka and its Service Discovery.

Spring Boot and Flask Microservice Discovery with Netflix Eureka

Marcus Sanatan

Naazneen Jatu

We are going to build a RESTful API using Django without any external libraries or frameworks. Our API will be JSON based and perform CRUD operations on a fictional cart item model.

Creating a REST API in Python with Django

The <code>InputStream</code> class is a high-level class representing any input byte stream in Java. Various subclasses further specify its usage, such as the <code>BufferedInputStream</code>, <code>ByteArrayInputStream</code>, <code>SequenceInputStream</code>, etc.
Needless to say, an <code>InputStream</code> can store any data and in some cases, they store String contents as a byte stream.
In this tutorial, we'll take a look at how to convert an InputStream into a Java String.
Let's start off by making an <code>InputStream</code> that we'll be using throughout the examples. These can come from various sources, but let's make one from a String, to make it easy to verify if the output is correct:
<pre><code class="hljs">String string = &quot;Input data, to be converted into an InputStream.&quot;;
InputStream inputStream = new ByteArrayInputStream(string.getBytes());
</code></pre>
<code>InputStream</code> is an abstract class, and we've used one of its subclasses, <code>ByteArrayInputStream</code> to read the bytes of the String. Now, we've got an <code>InputStream</code> playing the role of actual input, that we can easily verify by comparing to the <code>string</code> instance.
Java has a plethora of classes to work with byte streams, and there's no shortage of options and approaches here. We'll be focusing on a few of them:
<ul>
<li><a href="#inputstreamtostringwithinputstreamreadallbytes">InputStream to String with InputStream.readAllBytes()</a> - Best Approach</li>
<li><a href="#inputstreamtostringwithbytearrayoutputstream">InputStream to String with ByteArrayOutputStream</a></li>
<li><a href="#inputstreamtostringwithinputstreamreader">InputStream to String with InputStreamReader</a></li>
<li><a href="#inputstreamtostringwithbufferedreaderlines">InputStream to String with BufferedReader.lines()</a></li>
<li><a href="#inputstreamtostringwithapachecommons">InputStream to String with Apache Commons</a></li>
</ul>
<h2 id="inputstreamtostringwithinputstreamreadallbytes">InputStream to String with InputStream.readAllBytes()</h2>
Since Java 9, this process has been simplified a lot. The <code>InputStream</code> is very commonly instantiated as a <code>ByteArrayInputStream</code>, before <code>toByteArray()</code> is called to retrieve the bytes from it.
This process is streamlined and replaced by the built-in <code>InputStream.readAllBytes()</code> method, which simply returns the bytes from the <code>InputStream</code> - a much-needed utility method.
The <code>String</code> class accepts a <code>byte</code> array into its constructor, out of which, a <code>String</code> is formed and returned, which makes this the easiest and most readable approach to convert an <code>InputStream</code> into a <code>String</code>:
<pre><code class="hljs">String result = new String(inputStream.readAllBytes());
System.out.println(result);
</code></pre>
This results in:
<pre><code class="hljs">Input data, to be converted into an InputStream.
</code></pre>
Note: If the <code>InputStream</code> contains more than <code>Integer.MAX_VALUE</code> bytes, the method naturally throws an <code>OutOfMemoryError</code>.
<h2 id="inputstreamtostringwithbytearrayoutputstream">InputStream to String with ByteArrayOutputStream</h2>
For versions prior to Java 9, the fastest way to convert an <code>InputStream</code> into a String is by using the <code>ByteArrayOutputStream</code>.
This approach relies on the fact that we can easily construct Strings from byte arrays, and the fact that <code>ByteArrayOutputStream</code> has a very handy <code>toString()</code> method.
This process is practically the reverse of what we did in the beginning - constructing an <code>InputStream</code> from a String:
<pre><code class="hljs">// Instantiate an OutputStream that&#x27;ll store the data from the InputStream
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

// For each line of the InputStream, write it to the OutputStream, and move to the next
for (int data = inputStream.read(); data != -1; data = inputStream.read()) {
 byteArrayOutputStream.write(data);
}

// Convert byte array into String
// Optional: You can set a character set via `StandardCharsets` here
String result = byteArrayOutputStream.toString(StandardCharsets.UTF_8);
System.out.println(result);
</code></pre>
The <code>inputStream.read()</code> method reads the next byte in the array, starting at the first one. Here, we save a reference to the first byte as a <code>data</code> of that reading operation, check if it's <code>-1</code> (reached the end of the stream) and move to the next byte with another <code>read()</code> operation.
Running this code results in:
<pre><code class="hljs">Input data, to be converted into an InputStream.
</code></pre>
<h2 id="inputstreamtostringwithinputstreamreader">InputStream to String with InputStreamReader</h2>
The <code>InputStream</code> and <code>OutputStream</code> classes are a part of the <code>java.io</code> package, which also includes a really handy <code>InputStreamReader</code> class, originally meant as the class to use to read <code>InputStream</code>s.
The <code>InputStreamReader</code> reads the bytes from the stream and decodes them into characters, for which you can optionally also specify via a <code>StandardCharsets</code> enumeration:
<pre><code class="hljs">// Read the InputStream into a Reader
Reader reader = new InputStreamReader(inputStream);

// Instantiate a StringBuilder to save the result
StringBuilder result = new StringBuilder();

// Read each byte and convert into a char, adding to the StringBuilder
for (int data = reader.read(); data != -1; data = reader.read()) {
 result.append((char)data);
}

// Convert StringBuilder to String
System.out.println(result.toString());
</code></pre>
This also results in:
<pre><code class="hljs">Input data, to be converted into an InputStream.
</code></pre>
<h2 id="inputstreamtostringwithbufferedreader">InputStream to String with BufferedReader</h2>
Instead of a <code>Reader</code>, you can also use a <code>BufferedReader</code>. A <code>BufferedReader</code> stores larger amounts of bytes in a buffer before performing any reading/writing operations. Due to less context switching, this is a more efficient way to read and write large amounts of data, while on smaller amounts, the difference is unnoticeable.
In the previous example, we could've wrapped the <code>InputStreamReader</code> into a <code>BufferedReader</code> instead:
<pre><code class="hljs">BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));

StringBuilder sb = new StringBuilder();

for (int data = reader.read(); data != -1; data = reader.read()) {
 sb.append((char)data);
}

System.out.println(sb.toString());
</code></pre>
This results in the same output:
<pre><code class="hljs">Input data, to be converted into an InputStream.
</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: This approach is preferred over the previous one, due to the increased efficiency, even though it may be unnoticeable on smaller amounts of data.

 </div>
 </div>
 </div>
 <h2 id="inputstreamtostringwithbufferedreaderlines">InputStream to String with BufferedReader.lines()</h2>
With Java 8, the <code>BufferedReader</code> class got a new <code>lines()</code> method, which returns a <code>Stream</code> of <code>String</code>s, for each line. This makes it effortless to read an <code>InputStream</code>, using the Stream API:
<pre><code class="hljs">BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));

String result = reader.lines().collect(Collectors.joining(System.lineSeparator()));

System.out.println(result);
</code></pre>
The <code>Collectors.joining()</code> method can work without us specifying a delimiter, though, it can lead to unexpected results when the input data has new lines. By setting the delimiter to <code>System.lineSeparator()</code>, we're allowing the underlying system's mechanism to kick in for the ends of lines.
This code results in:
<pre><code class="hljs">Input data, to be converted into an InputStream.
</code></pre>
<h2 id="inputstreamtostringwithapachecommons">InputStream to String with Apache Commons</h2>
Finally, let's take a look at how to achieve this through an external library - Apache Commons, which is present in a significant number of projects.
To use Apache Commons, we'll have to add its dependency to our own project:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;commons-io&lt;/groupId&gt;
 &lt;artifactId&gt;commons-io&lt;/artifactId&gt;
&lt;/dependency&gt;
</code></pre>
And with that out of the way, we can utilize its <code>IOUtils</code> class:
<pre><code class="hljs">String result = IOUtils.toString(inputStream);
System.out.println(result);
</code></pre>
The method also accepts an optional <code>StandardCharsets</code> enumeration:
<pre><code class="hljs">String result = IOUtils.toString(inputStream, StandardCharsets.UTF_8);
</code></pre>
Running this code results in:
<pre><code class="hljs">Input data, to be converted into an InputStream.
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've taken a look at how to convert an <code>InputStream</code> into a String in Java.
We've taken a look at the newest approach, by reading all bytes and constructing a String directly, as well as writing them into a <code>ByteArrayOutputStream</code>, before using a <code>Reader</code> and <code>BufferedReader</code> and finally topping it off with the use of Apache Commons' <code>IOUtils</code>.

In this tutorial, we'll take a look at how to convert an InputStream into a Java String, in a plethora of ways with practical examples.

Convert InputStream into a String in Java

Joris Schellekens

In this guide, we'll take a look at how to create a PDF Document in Python, using pText - a library for loading, manipulating and saving PDF documents, with examples.

Creating a PDF Document in Python with pText

Creating a PDF Document in Python with borb

<h2 id="introduction">Introduction</h2>
File access permissions and security are at the heart of *nix-based operating systems. File objects can belong to users and/or groups, and at times they need to be shared with various combinations of those two. There are multiple ways in *nix systems to reinforce secure sharing of these objects.
<blockquote>
We use the <code>chmod</code> utility to change or modify the file permissions.
</blockquote>
This guide discusses file permissions and how we can change them with <code>chmod</code>. While the explanations and code should work for almost all *nix-based systems, this guide was specifically written for Linux.
<h2 id="ownershipandpermissions">Ownership and Permissions</h2>
Before we could get into <code>chmod</code>, let's go over the basics of file and directory ownership in Linux. The files and directories that you find or create have access permissions provided in three categories of owners:
<table class="table table-striped" style="font-size:15px;overflow-x:auto;">
 <thead>
 <tr>
 <th>Owners</th>
 <th>Symbolic Representation</th>
 <th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td>Users</td>
 <td>u</td>
 <td>The primary owner of the file/directory object</td>
 </tr>
 <tr>
 <td>Groups</td>
 <td>g</td>
 <td>A user can be part of one or many groups</td>
 </tr>
 <tr>
 <td>Others</td>
 <td>o</td>
 <td>Other users who also aren't part of the group</td>
 </tr>
 </tbody>
</table>
These owners can have one or many of the following access permissions assigned:
<table class="table table-striped" style="font-size:15px;overflow-x:auto;">
 <thead>
 <tr>
 <th>Permission</th>
 <th>Symbolic Representation</th>
 <th>Octal Representation</th>
 <th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td>Read</td>
 <td>r</td>
 <td>4</td>
 <td>Permission to read, copy from directory</td>
 </tr>
 <tr>
 <td>Write</td>
 <td>w</td>
 <td>2</td>
 <td>Permission to write/edit, delete, add new files to directory</td>
 </tr>
 <tr>
 <td>Execute</td>
 <td>x</td>
 <td>1</td>
 <td>Permission to execute the binary</td>
 </tr>
 </tbody>
</table>
Let's get hands-on experience with <code>chmod</code> commands and permissions by first creating an empty file:
<pre><code class="hljs">$ touch temp.txt
</code></pre>
We will also be using the <code>ls -l</code> command very often to check access permissions. The <code>ls</code> command is used to list files, but the <code>-l</code> flag returns them in the long format, which also includes the information regarding access permissions:
<pre><code class="hljs">$ ls -l temp.txt
-rw-r--r-- 1 ubuntu ubuntu 0 Apr 20 22:17 temp.txt
</code></pre>
The left-hand side of the result contains information on access permissions. Though, they're not as intuitive as the two tables from just a moment ago. The result has several components:
<img src="https://stackabuse.s3.amazonaws.com/media/guide-to-chmod-1.jpg" alt="Fig.1 Long List &amp; Permissions Explanation">
The permissions can be split into three parts - each corresponding to the owners in the order - Users, Groups, and Others. You may have also noticed the name of the owners i.e. the user and the group to which the object belongs to.
The order of the permission for each codon of 3 is of the structure <code>rwx</code>. If one of these permissions is unavailable, the missing permission is replaced with a dash (-) like <code>rw-</code>. The other details are related to the file itself: its size, creation date, and name.
<h2 id="thechmodutility">The chmod Utility</h2>
The <code>chmod</code> utility helps us to assign permissions to file/directory objects. It has a special set of arguments, corresponding to the ownership and permissions:
<table class="table table-striped" style="font-size:15px;overflow-x:auto;">
 <thead>
 <tr>
 <th>Permission</th>
 <th>Symbolic Representation</th>
 <th>Octal Representation</th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td>read</td>
 <td>r</td>
 <td>4</td>
 </tr>
 <tr>
 <td>write</td>
 <td>w</td>
 <td>2</td>
 </tr>
 <tr>
 <td>execute</td>
 <td>x</td>
 <td>1</td>
 </tr>
 <tr>
 <td>no permission</td>
 <td>-</td>
 <td>0</td>
 </tr>
 </tbody>
</table>
For each owner, these permissions can be summed (for Octal Representation - e.g. 4+2 = 6 denotes read &amp; write permissions) or combined (for Symbolic Representation - e.g. <code>rw</code> denotes read &amp; write permissions).
This is key to understanding how the <code>chmod</code> command works. Let's modify the access permissions of the <code>temp.txt</code> file, and allow read, write and execute permissions to the User, but disallow any access to the Group and Others.
You can use either Octal Representation or Symbolic Representation for this:
<pre><code class="hljs">$ chmod 700 temp.txt
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/guide-to-chmod-2.jpg" alt="Fig.2 chmod depiction">
The octal notation - <code>700</code> can be broken down as:
<ul>
<li>The first octal integer position corresponds to the User and the number 7 itself is an octal representation of all permissions (<code>rwx</code>) i.e. 4+2+1 = 7.</li>
<li>The second and third octal integer positions correspond to the Group and Others, where the number 0 shows that there aren't any permissions to access the object.</li>
</ul>
Let's take a look at the permission on the <code>temp.txt</code> file now:
<pre><code class="hljs">$ ls -l temp.txt
-rwx------ 1 ubuntu ubuntu 0 Apr 20 22:19 temp.txt
</code></pre>
We can perform the same command, and assign the permissions in much the same way if we rewrite the <code>700</code> argument using the symbolic notation:
<pre><code class="hljs">$ chmod u+rwx,g-rwx,o-rwx temp.txt
</code></pre>
We remove permissions using a <code>-</code> sign, and added by <code>+</code>. When using the symbolic representation, owners are separated by commas <code>,</code>. Here, we've added the <code>rwx</code> permission to <code>u</code>, but removed it from <code>g</code> and <code>o</code>.
This results in the same access permissions:
<pre><code class="hljs">$ ls -l temp.txt
-rwx------ 1 ubuntu ubuntu 0 Apr 20 22:19 temp.txt
</code></pre>
Now, let's consider another command:
<pre><code class="hljs">$ chmod u+rwx,g-rw+x,o-rw+x temp.txt
</code></pre>
Here, we've intertwined pluses and minuses:
<ul>
<li><code>'u+rwx'</code> denotes that the read, write and execute permissions are provided to the User.</li>
<li><code>'g-rw+x'</code> and <code>'o-rw+x'</code> show that the Group and the Others are denied to perform any of the read/write operations but they are allowed to perform executions.</li>
</ul>
This is equivalent to <code>chmod 711 temp.txt</code> using octal representation.
Let's check the file again:
<pre><code class="hljs">$ ls -l temp.txt
-rwx--x--x 1 ubuntu ubuntu 0 Apr 20 22:19 temp.txt
</code></pre>
We can also use an <code>'='</code> sign to set/overwrite permissions to the corresponding owner. The aforementioned command could also be written as:
<pre><code class="hljs">$ chmod u=rwx,g=x,w=x temp.txt
</code></pre>
This, yet again, results in:
<pre><code class="hljs">$ ls -l temp.txt
-rwx--x--x 1 ubuntu ubuntu 0 Apr 20 22:19 temp.txt
</code></pre>
<h2 id="advancedchmodusagesuidguidandstickybits">Advanced chmod Usage - SUID, GUID and Sticky Bits</h2>
Now that the basics of <code>chmod</code> are clear, let's take it one step further by reviewing an extra set of special execution/deletion-only permissions that act as the fourth level of security to the existing read, write and execute permissions. These include:
<table class="table table-striped" style="font-size:15px;overflow-x:auto;">
 <thead>
 <tr>
 <th>Special Permission</th>
 <th>Symbolic Representation</th>
 <th>Octal Representation</th>
 <th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td>SUID (Set UserID)</td>
 <td>rw**s**------</td>
 <td>4</td>
 <td>Execution-Only permission defined at the User Level. It is used to provide user-like privileges to whoever executes the file(s) inside the directory objects.</td>
 </tr>
 <tr>
 <td>SGID (Set GroupID)</td>
 <td>---rw**s**---</td>
 <td>2</td>
 <td>Execution-Only permission defined at the Group Level. It is used to provide group-like privileges to whoever executes the file(s) inside the directory objects.</td>
 </tr>
 <tr>
 <td>Sticky Bit</td>
 <td>------rw**t**</td>
 <td>1</td>
 <td>Defined at the Others Level. It prevents the file or object from getting deleted. Only the Owner or Root can delete the file or object.</td>
 </tr>
 </tbody>
</table>
When calling the <code>chmod</code> utility, and setting the argument - the special permission precedes the regular permissions. If we want to add a special permission to our regular <code>700</code> argument, we simply add a digit beforehand:
<pre><code class="hljs">$ chmod 5700 temp.txt
$ ls -l temp.txt
-rws-----T 1 ubuntu ubuntu 0 Apr 20 22:19 temp.txt
</code></pre>
Here, the <code>5</code> defines the sum of <code>4+1</code>, which is a combination of the SUID and Sticky Bit permission. <code>700</code> represents the <code>'rwx'</code> permission for the Owner only. SUID overrides the owner permission, and whoever executes the file will always execute as the owner of the file. In addition to this, only the owner of the file will be able to delete it. In the output, notice the presence of the character <code>'T'</code>, which denotes that the Sticky Bit is set.
Let's rewrite the command, using symbolic representation:
<pre><code class="hljs">$ chmod u+srwx,g-rwx,o+t-rwx temp.txt
$ ls -l temp.txt
-rws-----T 1 ubuntu ubuntu 0 Apr 20 22:19 temp.txt
</code></pre>
Let's breakdown the argument by commas, since it's getting a bit long:
<ul>
<li><code>u+srwx</code>: The user has a <code>SUID</code> permission attached to it, along with <code>rwx</code>.</li>
<li><code>g-rwx</code>: The group is devoid of the <code>rwx</code> permissions.</li>
<li><code>o+t-rwx</code>: The <code>+t</code> denotes the addition of a <code>Sticky Bit</code> permission and the others are devoid of the <code>rwx</code> permissions.</li>
</ul>
If you happen to have another user, try switching to that user and check if you can delete the file. You should be getting a prompt just like this:
<pre><code class="hljs">$ sudo su unknown
$ rm temp.txt
rm: remove write-protected regular empty file &#x27;temp.txt&#x27;?
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this guide, we learned about file and directory ownership and permissions in Linux. We then used <code>chmod</code> to modify them. These commands can be quite useful in securing the files or directories with much ease in *nix-based Operating Systems.

Sathiya Sarathi Gunasekaran

In this guide, we discuss file ownership and permissions in Unix/Linux systems, and how to change them with chmod, through practical examples and explanations.

Guide to chmod

Guide to Understanding chmod

In this tutorial, we'll take a look at the legacy Django MongoDB Engine, covering some of the useful features of the library through examples in Python.

Guide to Using The Django MongoDB Engine with Python

Guide to Using the Django MongoDB Engine with Python

<h2 id="introduction">Introduction</h2>
Plotly is a JavaScript-based, Python data visualization library, focused on interactive and web-based visualizations. It has the simplicity of Seaborn, with a high-level API, but also the interactivity of Bokeh.
In addition to the core library's functionality, using the built-in Plotly Express with Dash, makes it an amazing choice for web-based applications and interactive, data-driven dashboards, usually written in Flask.
In this guide, we'll take a look at how to plot a Bar Plot with Plotly.
<blockquote>
Bar charts are most commonly used to visualize categorical data, where the height of each bar represents the number of occurrences in that category.
</blockquote>
<h2 id="plotabarplotwithplotly">Plot a Bar Plot with Plotly</h2>
To plot a Bar Plot in Plotly, you simply call the <code>bar()</code> function of the Plotly Express (<code>px</code>) instance, providing the <code>x</code> and <code>y</code> arguments with valid data:
<pre><code class="hljs">import plotly.express as px

x = [&#x27;Category 1&#x27;, &#x27;Category 2&#x27;, &#x27;Category 3&#x27;]
y = [5, 3, 6]

fig = px.bar(x, y)
fig.show()
</code></pre>
Here, we have three categories, as a list that we've provided to the <code>x</code> argument and a few scalar values we've provided to the <code>y</code> argument. This results in a simple and intuitive Bar Plot:
<img src="https://s3.stackabuse.com/media/articles/plotly-bar-plot-tutorial-and-examples-1.png" alt="">
However, we rarely work with lists when doing Data Visualization. Let's import the <a rel="nofollow noopener" target="_blank" href="https://www.kaggle.com/datasets/blastchar/telco-customer-churn">Telecom Users Dataset</a> and visualize the <code>InternetService</code> and <code>tenure</code> features through a Bar Plot.

 <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 dataset originally used for this article has been taken down, which has been replaced with the one linked above. While it looks to be the same dataset, note that your output may look different than what's shown here.

 </div>
 </div>
 </div>
 The <code>InternetService</code> feature is a categorical feature, that specifies which type of service the customer is using, while the <code>tenure</code> is a numerical feature that represents how long a customer has been with the company, in months:
<pre><code class="hljs">import pandas as pd
import plotly.express as px

df = pd.read_csv(&#x27;telecom_users.csv&#x27;)
print(df.head())
</code></pre>
This results in:
<pre><code class="hljs"> gender SeniorCitizen tenure InternetService ...
0 Male 0 72 No ...
1 Female 0 44 Fiber optic ...
2 Female 1 38 Fiber optic ...
3 Male 0 4 DSL ...
4 Male 0 2 DSL ...
</code></pre>
Now, let's go ahead and plot this data as a Bar Plot:
<pre><code class="hljs">import pandas as pd
import plotly.express as px

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

fig = px.bar(df, x = &#x27;InternetService&#x27;, y = &#x27;tenure&#x27;)
fig.show()
</code></pre>
To plot data from a dataset, we've provided the data source (<code>df</code>) as the first argument, and the column names we'd like to visualize to the <code>x</code> and <code>y</code> arguments. Plotly maps these, fetches the data and generates a plot:
<img src="https://s3.stackabuse.com/media/articles/plotly-bar-plot-tutorial-and-examples-2.png" alt="">
Now, the plot generated by Plotly actually separates each instance into a small stacked bar of its own on this plot, since several rows share the same <code>x</code> value, unlike the simple 1-to-1 mapping like we had in the first example.
We can see the cumulative number of months they've served to their customers, in parallel. While ~90K months may seem like an insane number of months (7500 years), the median <code>tenure</code> is <code>29</code> months:
<pre><code class="hljs">print(df[&#x27;tenure&#x27;].median()) # 29.0
</code></pre>
<h2 id="changebarplotcolorswithplotly">Change Bar Plot Colors with Plotly</h2>
It's easy to change the colors of each of the aforementioned instances, based on any other variable present in the dataset. These are most often other categorical features, such as <code>gender</code> or <code>SeniorCitizen</code>.
Grouping instances by another feature creates a Grouped Bar Plot, which are most commonly plotted one next to the other. By simply coloring instances based on another feature, we'll have a Stacked Grouped Bar Plot, since we'll have two or more groups of instances one on top of the other.
Let's take a look at the Bar Plot once again, once we color each plot depending on the <code>gender</code> feature:
<pre><code class="hljs">import pandas as pd
import plotly.express as px

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

fig = px.bar(df, x = &#x27;InternetService&#x27;, y = &#x27;tenure&#x27;, color=&#x27;gender&#x27;)
fig.show()
</code></pre>
Now, the default Plotly color-scheme will apply, and the instances will be sorted by color so they're not mish-mashed throughout the plot:
<img src="https://s3.stackabuse.com/media/articles/plotly-bar-plot-tutorial-and-examples-3.png" alt="">
Since we've got multiple rows sharing the same <code>x</code> values - these are plotted, essentially, as stacked grouped bars.
If we were to plot a different feature, that doesn't stack (isn't a binary choice of another feature), the plot would look fairly differently:
<pre><code class="hljs">import pandas as pd
import plotly.express as px

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

fig = px.bar(df, x=&#x27;tenure&#x27;, y=&#x27;MonthlyCharges&#x27;, color=&#x27;tenure&#x27;)

fig.show()
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/plotly-bar-plot-tutorial-and-examples-3-1.png" alt="">
When providing many color values, such as <code>0..70</code> via the <code>tenure</code> feature - you'll see beautiful gradients formed in your plots.
<h2 id="plotgroupedbarplotwithplotly">Plot Grouped Bar Plot with Plotly</h2>
Sometimes, it's easier to differentiate if we plot the bars one next to the other, instead of stacking them on top of each other. This is particularly useful when we have binary features, such as <code>SeniorCitizen</code> that only has two values. You can really have <code>n</code> values in features you group by, though, most groups don't really benefit us much if they're too large.
To do this, we can simply update the layout of the <code>Figure</code>, and set the <code>barmode</code> to <code>'group'</code>:
<pre><code class="hljs">import pandas as pd
import plotly.express as px

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

fig = px.bar(df, x = &#x27;InternetService&#x27;, y = &#x27;tenure&#x27;, color=&#x27;gender&#x27;)
fig.update_layout(barmode=&#x27;group&#x27;)
fig.show()
</code></pre>
Now, it's much easier to compare the number of instances:
<img src="https://s3.stackabuse.com/media/articles/plotly-bar-plot-tutorial-and-examples-4.png" alt="">
<h2 id="plotahorizontalbarplotwithplotly">Plot a Horizontal Bar Plot with Plotly</h2>
To plot a Bar Plot horizontally using Plotly, we can set the <code>orientation</code> argument to <code>h</code> (as opposed to the default <code>v</code>) while plotting the Bar Plot:
<pre><code class="hljs">import pandas as pd
import plotly.express as px

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

fig = px.bar(df, x=&#x27;MonthlyCharges&#x27;, y=&#x27;tenure&#x27;, color=&#x27;tenure&#x27;, orientation=&#x27;h&#x27;)

fig.show()
</code></pre>
Keep in mind that if you'd like to keep the X-Y relationship as it was before, you'll switch the <code>x</code> and <code>y</code> arguments. Running this code results in:
<img src="https://s3.stackabuse.com/media/articles/plotly-bar-plot-tutorial-and-examples-5.png" alt="">
<h2 id="orderingbarplotsinplotly">Ordering Bar Plots in Plotly</h2>
Plotly automatically orders the bars. You can directly modify this setting by updating the <code>Figure</code> parameters.
You can opt for manual ordering, or automatic ordering. For manual ordering, you can pass in a dictionary that contains the names of the features and their order, which will result in a fixed order, to the <code>category_orders</code> argument:
<pre><code class="hljs">import pandas as pd
import plotly.express as px

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

fig = px.bar(df, x=&#x27;InternetService&#x27;, y=&#x27;tenure&#x27;, color=&#x27;gender&#x27;,
 category_orders={&quot;InternetService&quot;: [&quot;DSL&quot;, &quot;Fiber optic&quot;, &quot;No&quot;],
 &quot;gender&quot;: [&quot;Female&quot;, &quot;Male&quot;]})
fig.show()
</code></pre>
Here, we've ordered the <code>InternetService</code> feature in a specific order, that we've manually set, as well as the <code>gender</code> feature.
Plotting the Bar Plot now will result in:
<img src="https://s3.stackabuse.com/media/articles/plotly-bar-plot-tutorial-and-examples-7.png" alt="">
Alternatively, especially if there's a large number of possible values - we might want to let Plotly automatically sort and order values of features. We can either sort them categorically or numerically.
And both of these can further be ordered in <code>ascending</code> or <code>descending</code> order. To order numerically, we invoke the <code>total</code> keyword, while we invoke the <code>category</code> keyword for categorical ordering.
By default, Plotly adjusts the ordering based on the provided data - in our case, it ordered it as <code>total ascending</code>. Let's change that around to <code>total descending</code>:
<pre><code class="hljs">fig.update_layout(xaxis={&#x27;categoryorder&#x27;:&#x27;total descending&#x27;})
</code></pre>
This results in:
<img src="https://s3.stackabuse.com/media/articles/plotly-bar-plot-tutorial-and-examples-8.png" alt="">
When ordering categorically, it sorts lexicographically:
<pre><code class="hljs">fig.update_layout(xaxis={&#x27;categoryorder&#x27;:&#x27;category ascending&#x27;})
</code></pre>
This results in:
<img src="https://s3.stackabuse.com/media/articles/plotly-bar-plot-tutorial-and-examples-9.png" alt="">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've taken a quick look at how to plot and customize Bar Plots with Plotly.
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>