<h2 id="introduction">Introduction</h2>
Currency is a very important part of our modern world. So, it's equally important for us to be able to properly express it in Java.
In this tutorial, we'll go over how to format numbers as currency Strings in Java.
<h2 id="formatnumberascurrencystring">Format Number as Currency String</h2>
Here's how you can easily format a number, such as a <code>double</code> into a currency String:
<pre><code class="hljs">double currencyAmount = 1500.00;
// Create a new Locale
Locale usa = new Locale(&quot;en&quot;, &quot;US&quot;);
// Create a Currency instance for the Locale
Currency dollars = Currency.getInstance(usa);
// Create a formatter given the Locale
NumberFormat dollarFormat = NumberFormat.getCurrencyInstance(usa);

// Format the Number into a Currency String
System.out.println(dollars.getDisplayName() + &quot;: &quot; + dollarFormat.format(currencyAmount));
</code></pre>
If we run this code, it'll result in:
<pre><code class="hljs">US Dollar: $1,500.00
</code></pre>
Formatting numbers in different currencies involves a few Java classes. Our example made use of the <code>Locale</code> and <code>Currency</code> classes from the <code>java.util</code> package. Additionally, we used the <code>NumberFormat</code> class, which can be found in the <code>java.text</code> package.
Let's dive deeper into these classes and write a method that formats our number into multiple currencies, depending on an input.
<h2 id="thelocaleclass">The Locale Class</h2>
Each <code>Locale</code> object expresses a geopolitical region and includes information such as language and location. Countries have unique ways of expressing currency. Instead of us having to manually format each currency differently, using <code>Locale</code> objects allow us to automate this process.
To create a new <code>Locale</code> object, we can use one of the three available constructors:
<pre><code class="hljs">Locale(String language);
Locale(String language, String country);
Locale(String language, String country, String variant);
</code></pre>
Do note, however, that the <code>String</code> parameters for the constructors cannot be arbitrary. You can find a full list of all supported locales in Java 8 <a href="https://www.oracle.com/java/technologies/javase/jdk8-jre8-suported-locales.html" target="_blank" rel="noopener nofollow">here</a>.
Now let's create some example <code>Locale</code> objects. We will reference these later when we are creating the actual method for printing out currency:
<pre><code class="hljs">Locale usa = new Locale(&quot;en&quot;, &quot;US&quot;);
Locale germany = new Locale(&quot;de&quot;, &quot;DE&quot;);
Locale japan = new Locale(&quot;jp&quot;, &quot;JP&quot;);
</code></pre>
Since we are working with currency, the first <code>String</code> parameter, language, will dictate the formatting of the currency value (ex. 1,000,000.00 or 1.000.000,00). The second <code>String</code> parameter, region, will determine which currency sign is used (ex. $ or ¥).
<h2 id="thecurrencyclass">The Currency Class</h2>
The second class that we need to understand is the <code>Currency</code> class. Each <code>Currency</code> object represents a world currency. We want to get a currency given our <code>Locale</code>, so we will be using the following method:
<pre><code class="hljs">Currency.getInstance(Locale locale);
</code></pre>
This will return the corresponding <code>Currency</code> instance for the specified <code>Locale</code> parameter. So, using the <code>Locale</code> objects we created previously, this is what we will do:
<pre><code class="hljs">Currency dollars = Currency.getInstance(usa);
Currency euros = Currency.getInstance(germany);
Currency yen = Currency.getInstance(japan);
</code></pre>
Now that we have created our three <code>Currency</code> instances, we can move on to our next class.
<h2 id="thenumberformatclass">The NumberFormat Class</h2>
The <code>NumberFormat</code> class has methods to format numbers based on locales. Countries have different ways of grouping numbers. For example, one thousand can be represented as &quot;1000&quot;, &quot;1,000&quot;, &quot;1 000&quot; and other variations.
We'll be using the <code>NumberFormat.getCurrencyInstance(Locale l)</code> method. This method returns a <code>NumberFormat</code> object that corresponds to the <code>Locale</code> parameter specified. This is how we'll be using it in our method:
<pre><code class="hljs">NumberFormat dollarFormat = NumberFormat.getCurrencyInstance(usa);
NumberFormat eurosFormat = NumberFormat.getCurrencyInstance(germany);
NumberFormat yenFormat = NumberFormat.getCurrencyInstance(japan);
</code></pre>
<h2 id="creatingamethodtoprintanumberasacurrency">Creating a Method to Print a Number as a Currency</h2>
Now that we have learned about the three classes needed for this program, we can start writing the actual method to print a <code>double</code> with currency formatting.
We'll also accept a String, specifying which currency we'd like to print it as:
<pre><code class="hljs">public static void printCurrency(double currencyAmount, String outputCurrency) {
 Locale locale;
 
 if (outputCurrency.equals(&quot;Yen&quot;)) {
 locale = new Locale(&quot;jp&quot;, &quot;JP&quot;);
 } else if(outputCurrency.equals(&quot;Euros&quot;)) {
 locale = new Locale(&quot;de&quot;, &quot;DE&quot;);
 } else if (outputCurrency.equals(&quot;Dollars&quot;)) {
 locale = new Locale(&quot;en&quot;, &quot;US&quot;);
 } else {
 locale = new Locale(&quot;en&quot;, &quot;US&quot;);
 }
 
 Currency currency = Currency.getInstance(locale);
 NumberFormat numberFormat = NumberFormat.getCurrencyInstance(locale);
 
 System.out.println(currency.getDisplayName() + &quot;: &quot; + numberFormat.format(currencyAmount)); 

 }
}
</code></pre>
Let's test this method out by calling it and passing in the appropriate arguments:
<pre><code class="hljs">printCurrency(1000000.00, &quot;Yen&quot;);
printCurrency(1000000.00, &quot;Dollars&quot;);
printCurrency(1000000.00, &quot;Euros&quot;);
</code></pre>
This results in:
<pre><code class="hljs">Japanese Yen: JPY 1,000,000
US Dollar: $1,000,000.00
Euro: 1.000.000,00 €
</code></pre>
For this example, we used a <code>double</code> and printed as currency with proper formatting. Other number types would work as well, but we advise to stick with <code>double</code> for currency values.
<h2 id="conclusion">Conclusion</h2>
In this article, we learned a bit about the <code>Locale</code>, <code>Currency</code>, and <code>NumberFormat</code> classes. We then applied this knowledge in a method that allowed us to correctly format and print a <code>double</code> as currency.

Guest Contributor

In this guide, you will use Java to format a number into a currency string. We use Locale, Currency and NumberFormat objects.

How to Format Number as Currency String in Java

<h2 id="introduction">Introduction</h2>
In this article we're going to be taking a look at the try/except clause, and specifically how you can catch multiple exceptions in a single line, as well as how to use the <code>suppress()</code> method.
Both of these techniques will help you in writing more accessible and versatile code that adheres to DRY (don't repeat yourself) principles.
Let's start by looking at the problem:
<pre><code class="hljs">try:
 do_the_thing()
except TypeError as e:
 do_the_other_thing()
except KeyError as e:
 do_the_other_thing()
except IndexError as e:
 do_the_other_thing()
</code></pre>
Brutal.
As we can see, this is very WET code, we repeat the same invocation multiple times. Practices like this can make our code's reading and refactoring a living nightmare.
<blockquote>
Rather than writing exceptions one after another, wouldn't it be better to group all of these exception handlers into a single line?
</blockquote>
<h2 id="multipleexceptions">Multiple Exceptions</h2>
If you're just here for a quick answer, it's simple: use a tuple.
All the errors contained in the exception line tuple will be evaluated together:
<pre><code class="hljs">try:
 do_the_thing()
except (TypeError, KeyError, IndexError) as e:
 do_the_other_thing()
</code></pre>
Easy, right?
<h2 id="avoidingbadpractices">Avoiding Bad Practices</h2>
<blockquote>
&quot;Errors should never pass silently.&quot; - <a rel="nofollow noopener" target="_blank" href="https://www.python.org/dev/peps/pep-0020/#:~:text=Errors%20should%20never%20pass%20silently,obvious%20way%20to%20do%20it.">The Zen of Python</a>.
</blockquote>
try/except clauses are probably the most misused pattern in Python.
Used improperly, they end up being the cliché of drunks and lampposts, being used only when the Python interpreter starts caroling the &quot;12 Errors of Christmas&quot;.
It's very tempting to just put a <code>try</code> and a bare exception on a problem to &quot;make it go away&quot;. By doing that, we're effectively sweeping the exceptions under the rug, which is a shame, especially since they can be wonderfully helpful in recovering from potentially fatal errors, or shining a light on hidden bugs.
That's why when using except clauses you should always be sure to specify the errors you know you could encounter, and exclude the ones you don't.
Letting your program fail is okay, even preferred, to just pretending the problem doesn't exist.
<blockquote>
&quot;Errors should never pass silently... unless explicitly silenced.&quot;
</blockquote>
However, once in a blue moon when you do get the opportunity to ignore exception handling, you can use <code>suppress()</code>:
<pre><code class="hljs">from contextlib import suppress

with suppress(TypeError, KeyError, IndexError):
 do_the_thing()
</code></pre>
The <code>suppress()</code> method takes a number of exceptions as its argument, and performs a try/except/pass with those errors. As you can see it also lets you write multiple exceptions in a single line.
This let's you avoid writing a try/except/pass manually:
<pre><code class="hljs">try:
 do_the_thing()
except (TypeError, KeyError, IndexError) as e:
 pass
</code></pre>
Better yet, it's also standard in any version of Python 3.4 and above!
<h2 id="conclusion">Conclusion</h2>
In this article, we've covered how to handle multiple exceptions in a single line. We've also briefly gone over some bad practices of ignoring exceptions, and used the <code>suppress()</code> function to suppress exceptions explicitly.

Spencer Porter

In this article, we've gone over how to catch multiple exceptions in one line in Python, with code examples. We've also covered some bad practices and how to avoid them.

Python: Catch Multiple Exceptions in One Line

<h2 id="introduction">Introduction</h2>
In this article, we'll take a look at how to check if a String starts with another String in Java.
This is is a fairly common task in programming, and is very similar to <a target="_blank" href="/java-check-if-string-contains-a-substring/">checking if a string contains a substring</a>. For example, this can come in useful if we want to filter out all of the words out of a huge selection starting with a specific String.
However, this problem differs from checking if a String only contains a specific substring, and there's a few ways to do so in both Core Java and Apache Commons:
<ul>
<li><a href="#stringstartswith">String.startsWith()</a></li>
<li><a href="#streamanymatch">Stream.anyMatch()</a></li>
<li><a href="#stringindexof">String.indexOf()</a></li>
<li><a href="#patternwithregexandmatcher">Pattern with Regex</a></li>
<li><a href="#usingaforloop">Using a for-loop</a></li>
<li><a href="#stringutilsindexof">StringUtils.indexOf()</a></li>
<li><a href="#stringutilsstartswith">StringUtils.startsWith()</a></li>
<li><a href="#stringutilsstartswithany">StringUtils.startsWithAny()</a></li>
<li><a href="#stringutilsstartswithignorecase">StringUtils.startsWithIgnoreCase()</a></li>
</ul>
<h2 id="corejava">Core Java</h2>
Let's start off with solutions that can easily be implemented using Core Java.
<h3 id="stringstartswith">String.startsWith()</h3>
This method does exactly what we need it to do - and is the most common way to solve this problem. It returns a <code>boolean</code>, which indicates if the string begins with the provided keyword:
<pre><code class="hljs">String string = &quot;every end is a new beginning&quot;;

System.out.println(string.toLowerCase().startsWith(&quot;new&quot;.toLowerCase()));
System.out.println(string.toLowerCase().startsWith(&quot;EVERY&quot;.toLowerCase()));
System.out.println(string.toLowerCase().startsWith(&quot;&quot;));
</code></pre>
Running this outputs:
<pre><code class="hljs">false
true
true
</code></pre>
Note: If the parameter passed is an empty string, the result is always <code>true</code>.
Of course, this method is case-sensitive, and should always be used in pair with <code>toLowerCase()</code> or <code>toUpperCase()</code> when we're just looking for a specific keyword and don't care if the cases match.
<h3 id="streamanymatch">Stream.anyMatch()</h3>
Another thing we could check for is if a String starts with multiple substrings. Say, we have a few standardized prefixes - we can use make a <code>Stream</code> of substrings, and run an <code>anyMatch()</code> check for the String we're checking in.
Let's take a look at how to do that:
<pre><code class="hljs">String string = &quot;every end is a new beginning&quot;;
System.out.println(Stream.of(&quot;every&quot;, &quot;none&quot;).anyMatch(string::startsWith));
</code></pre>
Here, we've created a <code>Stream</code> of possible substrings, and checked if any of them are present at the start of the given String with a method reference call to <code>startsWith()</code>.
This code results in:
<pre><code class="hljs">true
</code></pre>
<h3 id="stringindexof">String.indexOf()</h3>
The <code>indexOf()</code> method can be quite useful in solving a variety of problems concerning substrings, including checking if a string begins with a specific one.
The method returns the index of the first occurrence of a substring within a string if it's found, otherwise <code>-1</code>.
It has a few overloaded variants from which we'll only be needing just the one below, since the other ones have different appliances:
<pre><code class="hljs">public int indexOf(String str)
</code></pre>
If the <code>indexOf()</code> method returns <code>0</code>, that means our String begins with another we've given it as a parameter.
For example:
<pre><code class="hljs">String string = &quot;Just a sample String&quot;;

System.out.println(string.toLowerCase().indexOf(&quot;just&quot;.toLowerCase()));
System.out.println(string.toLowerCase().indexOf(&quot;String&quot;.toLowerCase()));
System.out.println(string.toLowerCase().indexOf(&quot;something else&quot;.toLowerCase()));
</code></pre>
will output:
<pre><code class="hljs">0
14
-1
</code></pre>
<ul>
<li>The answer we're looking for is found within our first example, as it returned <code>0</code> - exactly what we need, meaning our string begins with a given parameter.</li>
<li>We can clearly see that in the second example, the <code>&quot;String&quot;</code> parameter we've given is indeed found within our String, but at the position <code>14</code>, which is not what we were looking for.</li>
<li>The third example isn't even contained within our String, and returns <code>-1</code>.</li>
</ul>
Using the information above, we can accumulate the logic in a function:
<pre><code class="hljs">public static boolean startsWithSubstring(String text, String keyword) {
 return text.toLowerCase().indexOf(keyword.toLowerCase()) == 0;
}
</code></pre>
<h3 id="patternwithregexandmatcher">Pattern with Regex and Matcher</h3>
The <code>Pattern</code> class is a compiled representation of a regular expression. With this <code>Pattern</code> we can then generate an engine that recognizes said regular expression - we can generate a <code>Matcher</code>.
We'll be using the <code>find()</code> method in combination with <code>start()</code> to check if our <code>Matcher</code> instance begins with a given String:
<pre><code class="hljs">public static boolean startsWithSubstring(String text, String keyword) {
 String inputString = text.toLowerCase();
 String subString = keyword.toLowerCase();


 // We compile the regular expression to generate a Pattern object
 Pattern pattern = Pattern.compile(subString);

 // Then we generate an engine (Matcher) which can be used
 // to recognize and match the regular expression it was
 // generated from (in our case &quot;this&quot;).
 Matcher matcher = pattern.matcher(inputString);

 // find() compares the assigned and compiled patterns, and will return a boolean value indicating if they match.
 // That&#x27;s where the start() method comes into play; it returns the index of the position 
 // where the two strings matched, or -1 if it&#x27;s not found.
 if (matcher.find()) {
 return matcher.start() == 0;
 }
 return false;
}
</code></pre>
Let's test this method out:
<pre><code class="hljs">System.out.println(startsWithSubstring(string, &quot;every&quot;));
</code></pre>
This results in:
<pre><code class="hljs">true
</code></pre>
<h3 id="usingaforloop">Using a for-loop</h3>
A more low-level way of solving this problem would be using a for-loop.
We iterate through the whole length of the search string, we compare the first <code>searchString.length()</code> characters and return <code>true</code> if the all match.
Let's see how this all works in code:
<pre><code class="hljs">public static boolean startsWithSubstring(String text, String keyword) {
 for (int i = 0; i &lt; keyword.length(); i++) {
 if (text.toLowerCase().charAt(i) != keyword.toLowerCase().charAt(i)) {
 System.out.println(&quot;String doesn&#x27;t start with &quot; + &quot;\&quot;&quot; + keyword + &quot;\&quot;&quot;);
 return false;
 } else if (i == keyword.length() - 1) {
 System.out.println(&quot;String starts with &quot; + &quot;\&quot;&quot; + keyword + &quot;\&quot;&quot;);
 return true;
 }
 }
 return false;
}
</code></pre>
Let's test this method out:
<pre><code class="hljs">String string = &quot;Just a sample String&quot;;

System.out.println(startsWithSubstring(string, &quot;just&quot;));
System.out.println(startsWithSubstring(string, &quot;String&quot;));
System.out.println(startsWithSubstring(string, &quot;something else&quot;));
</code></pre>
This results in:
<pre><code class="hljs">String starts with &quot;just&quot;
true
String doesn&#x27;t start with &quot;String&quot;
false
String doesn&#x27;t start with &quot;something else&quot;
false
</code></pre>
By default, if we hadn't used <code>toLowerCase()</code> to even out the letters in the method itself, this approach would've been case-sensitive.
<h2 id="apachecommons">Apache Commons</h2>
The <a rel="nofollow noopener" target="_blank" href="https://commons.apache.org/">Apache Commons</a> library provides functionality that expands on the core Java Framework. It's one of the top third-party libraries and is present in many modern Java projects.
Apache Commons offers the <code>StringUtils</code> class, which contains many methods used to manipulate strings. Most of these methods are quite similar to the ones found in <code>java.lang.String</code>. The main difference being that all methods within the <code>StringUtils</code> class are null-safe.
However, for this task we'll need only a few methods from this class:
<ol>
<li><code>.indexOf()</code></li>
<li><code>.startsWith()</code></li>
<li><code>.startsWithIgnoreCase()</code>.</li>
</ol>
If not already, include the Apache Commons library in your project by adding a dependency to your <code>pom.xml</code> file if you're using Maven:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.apache.commons&lt;/groupId&gt;
 &lt;artifactId&gt;commons-lang3&lt;/artifactId&gt;
 &lt;version&gt;3.11&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
Or by adding it to Gradle:
<pre><code class="hljs">compile group: &#x27;org.apache.commons&#x27;, name: &#x27;commons-lang3&#x27;, version: &#x27;3.11&#x27;
</code></pre>
<h3 id="stringutilsindexof">StringUtils.indexOf()</h3>
This method has a few overloaded variants all of which return an <code>int</code> value indicating the index of the first occurrence of the substring, or <code>-1</code> if the substring doesn't appear at all.
We'll be focusing on the following variant of this method:
<pre><code class="hljs">public static int indexOf(CharSequence seq, CharSequence searchSeq)
</code></pre>
This method takes two <code>String</code>s/<code>CharSequence</code>s.
The <code>seq</code> parameter represents the String we'll be searching through to find <code>searchSeq</code>. Same logic applies as before - if this function returns <code>0</code>, we'll know that our string begins with a given <code>searchSeq</code> substring.
Also keep in mind that this method, like its counterpart, is also case-sensitive, so using <code>.toLowerCase()</code> or <code>.toUpperCase()</code> is required to achieve a case-insensitive behavior.
Using this method is very similar to using the <code>indexOf()</code> from <code>java.lang.String</code>:
<pre><code class="hljs">String string = &quot;a simple string to search in&quot;;

System.out.println(StringUtils.indexOf(string.toLowerCase(), &quot;a simple&quot;.toLowerCase()));
System.out.println(StringUtils.indexOf(string.toLowerCase(), &quot;string&quot;.toLowerCase()));
System.out.println(StringUtils.indexOf(string.toLowerCase(), &quot;something&quot;.toLowerCase()));
</code></pre>
This will yield:
<pre><code class="hljs">0
9
-1
</code></pre>
And thus, we can use this as a convenience method:
<pre><code class="hljs">public static boolean startsWithSubstring(String text, String keyword) {
 return StringUtils.indexOf(text.toLowerCase(), keyword.toLowerCase()) == 0;
}
</code></pre>
<h3 id="stringutilsstartswith">StringUtils.startsWith()</h3>
This method does exactly what you'd expect. It's also case-sensitive like it's predecessors, and accepts the same two parameters.
It returns <code>true</code> if the <code>text</code> begins with the <code>keyword</code>, or <code>false</code> if it doesn't.
Comparing two <code>null</code> values will result in <code>true</code>:
<pre><code class="hljs">String string = &quot;a simple string to search in&quot;;

System.out.println(StringUtils.startsWith(string.toLowerCase(), &quot;A SIMPLE&quot;));
System.out.println(StringUtils.startsWith(string.toLowerCase(), &quot;A SIMPLE&quot;.toLowerCase()));
System.out.println(StringUtils.startsWith(null, null));
</code></pre>
Running this will output:
<pre><code class="hljs">false
true
true
</code></pre>
<h3 id="stringutilsstartswithany">StringUtils.startsWithAny()</h3>
The <code>startsWithAny()</code> doesn't have a counterpart in the <code>java.lang.String</code> class, and is unique to <code>StringUtils</code>.
However, it is very close to what we did with <code>anyMatch()</code> on a Stream - It checks if a <code>String</code> begins with any of the given substrings, returning <code>true</code> or <code>false</code> appropriately.
It's also case-sensitive:
<pre><code class="hljs">String string = &quot;a simple string to search in&quot;;

System.out.println(StringUtils.startsWithAny(string, &quot;something&quot;, &quot;a simple&quot;));
System.out.println(StringUtils.startsWithAny(string, &quot;something&quot;, &quot;string&quot;));
System.out.println(StringUtils.startsWithAny(string, &quot;something&quot;, null));
System.out.println(StringUtils.startsWithAny(string, &quot;something&quot;, &quot;&quot;));
</code></pre>
Running this gives us:
<pre><code class="hljs">true
false
false
true
</code></pre>
<h3 id="stringutilsstartswithignorecase">StringUtils.startsWithIgnoreCase()</h3>
Since it can get annoying to call <code>toLowerCase()</code> all the time on Strings during comparison, you can alternatively sue the <code>startsWithIgnoreCase()</code> method.
Like the <code>startsWith()</code> method from the same class, it takes two Strings (or <code>CharSequence</code>) types, and the return value is <code>true</code> or <code>false</code> depending on if the text actually starts with the provided keyword:
<pre><code class="hljs">String string = &quot;a simple string to search in&quot;;

System.out.println(StringUtils.startsWithIgnoreCase(string, &quot;something&quot;));
System.out.println(StringUtils.startsWithIgnoreCase(string, &quot;A SIMPLE&quot;));
System.out.println(StringUtils.startsWithIgnoreCase(string, &quot;&quot;));
System.out.println(StringUtils.startsWithIgnoreCase(string, null));
</code></pre>
Running this outputs:
<pre><code class="hljs">false
true
true
false
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over all the different method of checking if a <code>String</code> begins with another <code>String</code>, both in core Java and utilizing the Apache Commons library.
In conclusion, there are many different ways to accomplish this task. In reality, we could have combined any of the methods above in order to find an index that a substring starts on, and from there on check where the substring is positioned at.
Most of the time, just using the <code>startsWith()</code> methods, or <code>startsWithIgnoreCase()</code> would be enough to solve this problem and would also give the cleanest, shortest code.

Branko Ilic

In this tutorial, we'll go over examples of how to check if a String starts with a substring in Java. We'll cover Core Java as well as Apache Commons methods.

Java: Check if String Starts with Another String

<h2 id="introduction">Introduction</h2>
When managing a computer, we may want to automate some tasks to run in certain periods or at the same time on each day/week/month. On a desktop, we may schedule update checks or virus scans. On a server, it's not uncommon for a myriad of checks and clean up routines to be scheduled to ensure applications are running optimally.
In this article, we will look at the <code>cron</code> program. This utility is a task scheduler for Unix-like systems. After going over cron basics, we'll look at the <code>crontab</code> command to manage our scheduled tasks.
<h2 id="whatiscronwhatisacrontab">What is Cron? What is a Crontab?</h2>
To master <code>cron</code> and scheduling, it helps to have a grasp of various but similar terminology used.
Cron is the program that schedules scripts or commands to run at user-specified times. A cron expression is a string that details the schedule to trigger a command. A cron table is a configuration file containing the shell commands in each line preceded by a cron expression.
Here's an image with a system crontab that references two external scripts:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-use-the-crontab-command-in-unix-1.png" alt="Editing the crontabs directly">
Generally, cron tables look like this:
<pre><code class="hljs">&lt;cron-expression&gt; &lt;command&gt;
&lt;cron-expression&gt; &lt;command&gt;
</code></pre>
When your computer first starts up, cron searches for all crontabs in system-configured directories. The directory varies from OS to OS but it's typically <code>/etc/crontab</code> for special system-wide crontabs and a local directory for the user who's logged in. These are both loaded into memory.
The cron program wakes up every minute and checks the crontab in memory to see if any commands need to be run at the current minute. It executes all scheduled commands and sleeps again.
There are two methods by which the cron jobs can be scheduled:
<ol>
<li>Edit the <code>crontab</code> directly</li>
</ol>
We can view the cron jobs we have scheduled by running this command:
<pre><code class="hljs">$ crontab -l
</code></pre>
If we would like to add or edit a cron job, we can then use this command:
<pre><code class="hljs">$ crontab -e
</code></pre>
This is the preferred method to edit crontabs because it selects the user crontab and not the system one, and it also catches syntax errors.
<ol start="2">
<li>Copying the scripts to the <code>/etc/cron.*</code> directories</li>
</ol>
If scheduling the scripts for accurate time slots is not required, the scripts can also be moved inside certain pre-built cron schedule folders, for the crontab to pick them up for execution. These predefined directories that act as placeholders include:
<table class="table table-striped" style="font-size:15px;overflow-x:auto;">
<thead>
 <tr>
 <th>Location</th>
 <th>Execution Schedule</th>
 </tr>
</thead>
<tbody>
 <tr>
 <td>/etc/cron.hourly/</td>
 <td>Once every hour</td>
 </tr>
 <tr>
 <td>/etc/cron.daily/</td>
 <td>Once per day, everyday</td>
 </tr>
 <tr>
 <td>/etc/cron.monthly/</td>
 <td>Once per month, every month</td>
 </tr>
 <tr>
 <td>/etc/cron.weekly/</td>
 <td>Once per week, every week</td>
 </tr>
</tbody>
</table>
The users can copy their scripts to the appropriate directories depending on which frequency they need to be run. The crontab file present in <code>/etc/crontab</code> contains the cron expressions defined for each directory and it checks every minute if the time is right for the scripts are to be executed:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-use-the-crontab-command-in-unix-2.png" alt="Copying scripts to the corresponding /etc/cron.* directories">
Note that scripts placed in these special folders are system-wide cron jobs and not user-specific ones.
<h2 id="creatingacronexpression">Creating a Cron Expression</h2>
Each entry of the crontab contains a cron expression, a user name, and the command to be executed separated with white spaces or tabs:
<pre><code class="hljs"> * * * * * user-name command-or-file-to-be-executed
# &lt;-----------&gt; &lt;-------&gt; &lt;----------------------------&gt;
# Cron
# Expression
</code></pre>
Note: The <code>user-name</code> column is used when editing the system-wide crontab. A user-specific crontab does not need it because that info is already known.
The 5 asterisks (<code>* * * * *</code>) in the cron expression can be substituted with numbers. Their positions indicate their value:
<table class="table table-striped" style="font-size:15px;overflow-x:auto;">
<thead>
 <tr>
 <th>* Position</th>
 <th>Description</th>
 <th>Allowed numeric values</th>
 </tr>
</thead>
<tbody>
 <tr>
 <td>1</td>
 <td>Minute</td>
 <td>0-59</td>
 </tr>
 <tr>
 <td>2</td>
 <td>Hour</td>
 <td>0-23</td>
 </tr>
 <tr>
 <td>3</td>
 <td>Day of Month</td>
 <td>1-31</td>
 </tr>
 <tr>
 <td>4</td>
 <td>Month</td>
 <td>0-12</td>
 </tr>
 <tr>
 <td>5</td>
 <td>Day of Week [0 represents Sunday & Saturday represents 6]</td>
 <td>0-6</td>
 </tr>
</tbody>
</table>
Alongside numbers, there are special characters we can use when editing a crontab:
<table class="table table-striped" style="font-size:15px;overflow-x:auto;">
<thead>
 <tr>
 <th>Characters</th>
 <th>Description</th>
 </tr>
</thead>
<tbody>
 <tr>
 <td>*</td>
 <td>Defining this will run the command for each time frame. For example, * defined under the minute column, will execute the script every minute</td>
 </tr>
 <tr>
 <td>,</td>
 <td>To repeat a task in multiple different time frames, commas can be used. For example, to run a script every 10 minutes, the minute column can be given as 0,10,20,30,40,50</td>
 </tr>
 <tr>
 <td>/</td>
 <td>An alternative, simpler version of ",". To run a script every 10 minutes, the minute column can be given as */10</td>
 </tr>
 <tr>
 <td>-</td>
 <td>Specifies a range of values. To run a script every minute for the first 10 minutes, the expression in the minute column can be given as: 0-10</td>
 </tr>
</tbody>
</table>
That's a lot of options to understand, it might be best to show how they work with some examples:
<ol>
<li>Here's how to run <code>echo &quot;hello there!&quot;</code> on the &quot;4th day of every week&quot; (i.e. on Thursday) at 12:10 hours:</li>
</ol>
<pre><code class="hljs">10 12 * * 4 root echo &quot;hello there!&quot;
</code></pre>
<ol start="2">
<li>And here's a more complicated example where we save disk usage every 20 minutes on the first 10 days of the last three months of the year:</li>
</ol>
<pre><code class="hljs">*/20 * 1-10 10,11,12 * df -h &gt;&gt; /tmp/diskusage
</code></pre>
Cron expressions can be overwhelming at first sight. There are numerous tools available online to simplify the creation of expressions; <code>crontab.guru</code> is one of the widely popular tools available online at <a href="https://crontab.guru/" rel="nofollow noopener" target="_blank">crontab.guru/</a>.
Let's use crontab.guru to check if our second express is valid: <a href="https://crontab.guru/#*/20_*_1-10_10,11,12_*" rel="nofollow noopener" target="_blank">crontab.guru/#*/20_*_1-10_10,11,12_*</a>.
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-use-the-crontab-command-in-unix-3.png" alt="Copying scripts to the corresponding /etc/cron.* directories">
<h2 id="handsonguidecreatingacronjobtoemaildiskandmemoryusage">Hands-on Guide: Creating a Cron Job to Email Disk and Memory Usage</h2>
In an IT department, system administrators and other operators frequently monitor computer resources such as memory and disk size. Crontab is commonly used to ensure monitoring scripts are run continuously.
We are going to create a cron job that monitors disk and RAM usage using <a href="https://github.com/datawrangl3r/watchmon" rel="nofollow noopener" target="_blank">Watchmon</a>. If either metric is above a certain threshold, we will get an email to alert us. We'll put this script in a cron job that runs every minute.
The following demo was tested on <code>Ubuntu 20.04.1 LTS</code>. This example is configured to send an email to a Gmail account, you may need to tweak your configurations for other email providers.
<ul>
<li>You first need to install watchmon. Follow their <a href="https://github.com/datawrangl3r/watchmon" rel="nofollow noopener" target="_blank">README</a> to learn how to set it up:</li>
</ul>
<pre><code class="hljs">$ git clone https://github.com/datawrangl3r/watchmon
$ cd watchmon
$ bash setup.sh
</code></pre>
<ul>
<li>The script will start the cron process, install <a a href="http://www.mutt.org/" rel="nofollow noopener" target="_blank">http://www.mutt.org/</a>, a command-line SMTP client, to send emails. Once installed, use your text editor to the <code>mutt.rc</code> file in your home directory: <code>/home/user/mutt/mutt.rc</code>.</li>
</ul>
Edit your file so it looks like this, changing the template data with your email:
<pre><code class="hljs">set ssl_starttls=yes
set ssl_force_tls=yes

set imap_user = &quot;change_this_user_name@gmail.com&quot;
set imap_pass = &quot;PASSWORD&quot;

set from=&quot;change_this_user_name@gmail.com&quot;
set realname=&quot;Your Name&quot;

set folder = &quot;imaps://imap.gmail.com/&quot;
set spoolfile = &quot;imaps://imap.gmail.com/INBOX&quot;
set postponed=&quot;imaps://imap.gmail.com/[Gmail]/Drafts&quot;

set header_cache = &quot;~/.mutt/cache/headers&quot;
set message_cachedir = &quot;~/.mutt/cache/bodies&quot;
set certificate_file = &quot;~/.mutt/certificates&quot;

set smtp_url = &quot;smtps://change_this_user_name@gmail.com:PASSWORD@smtp.gmail.com:465/&quot;

set move = no
set imap_keepalive = 900
</code></pre>
<ul>
<li>Since Google doesn't allow its services to be accessible by less secure apps, we need to enable access for the email account to be used in the SMTP settings. Visit <a a href="https://myaccount.google.com/security" rel="nofollow noopener" target="_blank">https://myaccount.google.com/security</a>, and toggle the less secure app access to ON, as shown in the gif below:</li>
</ul>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-use-the-crontab-command-in-unix-4.gif" alt="Allowing access to the less secure apps on gmail">
<ul>
<li>Now that our scripts and email account configurations are ready, we can set up our crontab. Edit your crontab by invoking:</li>
</ul>
<pre><code class="hljs">$ crontab -e
</code></pre>
Now enter the corresponding cron expression and path to the executable with arguments. Note that the path on your machine will differ from what is shown below:
<pre><code class="hljs">* * * * * /mnt/c/Users/sathy/Documents/datawrangler/watchmon/watchmon.sh -t=40 -e=sathyasarathi90@gmail.com
</code></pre>
This can be configured as shown below:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-use-the-crontab-command-in-unix-5.gif" alt="Figure 5: Allowing access to the less secure apps on gmail">
The cron utility makes sure to execute the script every minute and as a result, an email is sent from the machine to the recipients until the disk space or memory of the machine is cleared.
<h2 id="cronjobsanddealingwithfailures">Cron Jobs and Dealing with Failures</h2>
Although crontabs are very powerful, they can't alert the user if an underlying job is not triggered or the scheduled executable encounters an error. The logs for each job run can be found in the <code>/var/log/syslog</code> file. Be sure to review your logs after activities are scheduled.
Aside from cron and command errors, many crontabs are plagued by human errors. When setting up cron jobs, here are some common reasons why your cron job may not run as you'd expect it to:
<ul>
<li>
The scripts don't have the execute permission for it. Those executables that are to be run as cron jobs should have the permission as <code>755</code> i.e. <code>rwx-rw-rw</code>. The cron utility can only execute scripts if the user has executable permissions for it.
</li>
<li>
The crontab is syntactically correct but the wrong path was used for the jobs. It's important to specify the absolute path to the executable and the command itself. Relative paths need to be avoided at all costs.
</li>
<li>
The command or script is not being run with the necessary environment variables to work. In these cases, make sure that the script you run can set up the required env vars when running as a cron job.
</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
In this article, we have looked at the cron program, cron expressions, and crontabs. We used the <code>crontab</code> command to list and edit cron jobs. Crontabs are some of the best tools for Unix-like systems to automate repetitive tasks. What would you schedule with a cron job?

Marcus Sanatan

Sathiya Sarathi Gunasekaran

Cron jobs are scheduled activities in Unix-like systems. In this article, you will use the crontab command to add and manage cron jobs on Linux.

How to Use the Crontab Command in Unix

How to Use the crontab Command in Unix

Kristina Popovic

In this guide, we'll go over all you need to know to do Data Visualization in Python with Pandas - Bar Charts, Histograms, Area Plots, Pie Charts, Density Plots and Scatter Matrices.

Introduction to Data Visualization in Python with Pandas

Guide to Data Visualization in Python with Pandas

<h2 id="introduction">Introduction</h2>
One of the biggest challenges the developers are facing is being Agile or, in other words, being able to deliver stable releases of the products on time. With every Sprint, we need to deliver new features, bug-free features.
And why bother with building, testing, and deploying manually when we could have an automated process? A process that would check every piece of code before merging it in the stable branch and then deploying it. For example, deploying it on a testing machine ready for the QA team.
There are many tools for implementing this CI/CD process, but we'll stick with an awesome open-source tool, Jenkins.
Jenkins is an automation server. It helps automate building, testing, and deploying your application. Jenkins supports Git and Maven which will be our guest stars in this mini project.
This article will guide you through configuring the Jenkins process to be triggered every time a commit is made. Then we'll make sure our GitHub repository is configured properly for this scenario. Lastly, we will make a small test to show that everything works properly.
<h2 id="prerequisites">Prerequisites</h2>
For you to be able to follow this tutorial, some small things need to be set up.
<ul>
<li>A Jenkins server. You can use DigitalOcean to create a droplet with Jenkins ready to use. It should take less than 5 minutes.</li>
<li>A GitHub repository. Note that you can use and source control hosting provider as long as they provide you the ability to add Webhooks.</li>
<li>A Spring Boot application with tests. If you don't have one already you can clone <a rel="nofollow noopener" target="_blank" href="https://github.com/alexchirea/SimpleSpringBootApp">this</a> repository.</li>
</ul>
<h2 id="configuringjenkins">Configuring Jenkins</h2>
So after you created the Jenkins droplet, there are some steps you need to follow for the machine to be up and running.
Let's connect to our newly created droplet and prepare our environment. We'll start by running some commands in the terminal:
<pre><code class="hljs">$ ssh root@YOUR_VM_IP
</code></pre>
You will be asked to create your Jenkins password. Use a strong password and restart your Jenkins service:
<pre><code class="hljs">$ systemctl restart jenkins
</code></pre>
Your Jenkins server is now accessible at the following address <code>http://YOUR_VM_IP:8080</code> and you should see something like this. After that, you'll be redirected to the login page:
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-1.png" alt="jenkins loading screen">
And voilà, we are ready!
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-2.png" alt="jenkins login page">
The default username is <code>admin</code>, and the password is the one you created at the beginning.
Before we create our first project, let's go to Manage Jenkins ~&gt; Manage Plugins and install GitHub Pull Request Builder.
Now go to Manage Jenkins ~&gt; Configure System set up the GitHub server. Let's go and click on New Item in the upper left corner of the screen:
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-3.png" alt="click on new item jenkins">
Now, go ahead and type a name for your new project and select Freestyle project:
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-4.png" alt="create a new freestyle project jenkins">
We need to specify some parameters for the project, so Jenkins will know what commit it should use for the build and test part.
The first thing we need to do is to specify the project URL, under the General tab, and GitHub project.
Under Source Code Management tab, select Git. After you enter your Repository URL and your credentials, under Branched to build, use <code>${ghprbActualCommit}</code>.
Click on the Advanced... button and add the following details:
<ul>
<li>Name: <code>origin</code></li>
<li>Refspec: <code>+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*</code></li>
</ul>
Note: This value is required in order to build only the pull requests.
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-5.png" alt="source code management jenkins">
After we have configured our repository, we need to specify when this job will be triggered. For that, go to Build Triggers tab and select GitHub Pull Request Builder.
Firstly, select the credentials configured earlier and check Use GitHub Hooks for build triggering. Now, add a Update commit status during build trigger and configure it like in the image:
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-6.png" alt="commit status update during jenkins build">
Add a Build Status Messages trigger for <code>SUCCESS</code>, <code>ERROR</code>, and <code>FAILURE</code>.
For the Build phase we'll add Invoke top-level Maven targets with the following settings:
<ul>
<li>Maven version - your desired Maven version, can be configured from System Configuration</li>
<li>Goals - <code>clean install -U</code></li>
<li>POM - <code>pom.xml</code></li>
</ul>
Click Save and we are done!
<h2 id="githubrepositoryconfiguration">GitHub Repository Configuration</h2>
We've managed so far to configure the Jenkins workflow, but what about GitHub? That's what we're going to do right now.
Go to Settings on your repository page and select the Webhooks option from the left menu. Add a new webhook with the following details:
For the Payload URL type <code>http://YOUR_VM_IP:8080/ghprbhook/</code> and we'll select Pull Requests as the triggering option. The content type should be <code>application/json</code>. Leave the Secret field empty and Save.
<h2 id="testingtheworkflow">Testing the Workflow</h2>
The moment we've been waiting for. Create a new branch, push it to GitHub, and then create a Pull Request. As soon as we create the Pull Request, a job will be triggered on Jenkins:
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-7.png" alt="github pull request jenkins">
Soon, a Details link will appear on the pull request's page. If you click on the link, you'll see a page like the this one:
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-8.png" alt="jenkins job triggered">
Now if we go to the Console Output we can see that all the tests have passed:
<pre><code class="hljs">[INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0
...
Finished: SUCCESS
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-9.png" alt="success build jenkins">
For the sake of this tutorial, I'll make another commit with a failing test to see that it works properly. And the result:
<pre><code class="hljs">[ERROR] Tests run: 3, Failures: 1, Errors: 0, Skipped: 0
...
Finished: FAILURE
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-19.png" alt="failing build jenkins">
Here, we've successfully implemented a gated check-in for Spring Boot projects, using GitHub and Jenkins.
<h2 id="conclusion">Conclusion</h2>
Software Engineers are expected to provide bug-free solutions to their clients. With complex logic, it becomes paramount to test software and ensure checks and test cases to make sure that the project is stable.
In this article, we've implemented a gated check-in for Spring Boot projects, using GitHub and Jenkins, to ensure passing checks in the code we push.

Alex Chirea

In this tutorial, we'll implement a gated check-in for Spring Boot Projects using GitHub and Jenkins to ensure passing checks for each GitHub commit/pull request.

Set Up Gated Checkin for Spring Boot Projects with Github and Jenkins

Set Up Gated Check-in for Spring Boot Projects with Github and Jenkins

<h2 id="introduction">Introduction</h2>
Selecting a random element or value from a list is a common task - be it for randomized results from a list of recommendations or just a random prompt.
In this article, we'll take a look at how to randomly select elements from a list in Python. We'll cover the retrieval of both singular random elements, as well as retrieving multiple elements - with and without repetition.
<h3 id="selectingarandomelementfrompythonlist">Selecting a Random Element from Python List</h3>
The most intuitive and natural approach to solve this problem is to generate a random number that acts as an index to access an element from the list.
To implement this approach, let's look at some methods to generate random numbers in Python: <code>random.randint()</code> and <code>random.randrange()</code>. We can additionally use <code>random.choice()</code> and supply an iterable - which results in a random element from that iterable being returned back.
<h3 id="usingrandomrandint">Using random.randint()</h3>
<code>random.randint(a, b)</code> returns a random integer between <code>a</code> and <code>b</code> inclusive.
We'll want random index in the range of <code>0</code> to <code>len(list)-1</code>, to get a random index of an element in the list:
<pre><code class="hljs">import random

letters = [&#x27;a&#x27;, &#x27;b&#x27;, &#x27;c&#x27;, &#x27;d&#x27;, &#x27;e&#x27;, &#x27;f&#x27;]
random_index = random.randint(0,len(letters)-1)

print(letters[random_index])
</code></pre>
Running this code multiple times yields us:
<pre><code class="hljs">e
c
f
a
</code></pre>
<h3 id="usingrandomrandrange">Using random.randrange()</h3>
<code>random.randrange(a)</code> is another method which returns a random number <code>n</code> such that <code>0 &lt;= n &lt; a</code>:
<pre><code class="hljs">import random

letters = [&#x27;a&#x27;, &#x27;b&#x27;, &#x27;c&#x27;, &#x27;d&#x27;, &#x27;e&#x27;, &#x27;f&#x27;]
random_index = random.randrange(len(letters))

print(letters[random_index])
</code></pre>
Running this code multiple times will produce something along the lines of:
<pre><code class="hljs">f
d
d
e
</code></pre>
As <code>random.randrange(len(letters))</code> returns a randomly generated number in the range <code>0</code> to <code>len(letters) - 1</code>, we use it to access an element at random in <code>letters</code>, just like we did in the previous approach.
This approach is a tiny bit simpler than the last, simply because we don't specify the starting point, which defaults to <code>0</code>.
<h3 id="usingrandomchoice">Using random.choice()</h3>
Now, an even better solution than the last would be to use <code>random.choice()</code> as this is precisely the function designed to solve this problem:
<pre><code class="hljs">import random 

letters = [&#x27;a&#x27;, &#x27;b&#x27;, &#x27;c&#x27;, &#x27;d&#x27;, &#x27;e&#x27;, &#x27;f&#x27;]

print(random.choice(letters))
</code></pre>
Running this multiple times results in:
<pre><code class="hljs">b
e
e
f
e
</code></pre>
<h2 id="selectingmorethanonerandomelementfrompythonlist">Selecting More than One Random Element from Python List</h2>
<h3 id="usingrandomsample">Using random.sample()</h3>
The first method that we can make use of to select more than one element at random is <code>random.sample()</code>. It produces a sample, based on how many samples we'd like to observe:
<pre><code class="hljs">import random 

letters = [&#x27;a&#x27;, &#x27;b&#x27;, &#x27;c&#x27;, &#x27;d&#x27;, &#x27;e&#x27;, &#x27;f&#x27;]

print(random.sample(letters, 3))
</code></pre>
This returns a list:
<pre><code class="hljs">[&#x27;d&#x27;, &#x27;c&#x27;, &#x27;a&#x27;]
</code></pre>
This method selects elements without replacement, i.e., it selects without duplicates and repetitions.
If we run this:
<pre><code class="hljs">print(random.sample(letters, len(letters)))
</code></pre>
Since it doesn't return duplicates, it'll just return our entire list in a randomized order:
<pre><code class="hljs">[&#x27;a&#x27;, &#x27;e&#x27;, &#x27;c&#x27;, &#x27;d&#x27;, &#x27;f&#x27;, &#x27;b&#x27;]
</code></pre>
<h3 id="usingrandomchoices">Using random.choices()</h3>
Similar to the previous function, <code>random.choices()</code> returns a list of randomly selected elements from a given iterable. Though, it doesn't keep track of the selected elements, so you can get duplicate elements as well:
<pre><code class="hljs">import random 

letters = [&#x27;a&#x27;, &#x27;b&#x27;, &#x27;c&#x27;, &#x27;d&#x27;, &#x27;e&#x27;, &#x27;f&#x27;]

print(random.choices(letters, k=3))
</code></pre>
This returns something along the lines of:
<pre><code class="hljs">[&#x27;e&#x27;, &#x27;f&#x27;, &#x27;f&#x27;]
</code></pre>
Also, if we run:
<pre><code class="hljs">print(random.choices(letters, k = len(letters)))
</code></pre>
It can return something like:
<pre><code class="hljs">[&#x27;d&#x27;, &#x27;e&#x27;, &#x27;b&#x27;, &#x27;d&#x27;, &#x27;d&#x27;, &#x27;d&#x27;]
</code></pre>
<code>random.choices</code> returns a <code>k</code>-sized list of elements selected at random with replacement.
This method can also be used implement weighted random choices which you can explore further in the <a rel="nofollow noopener" target="_blank" href="https://docs.python.org/3/library/random.html">official Python documentation</a>.
<h2 id="selectingrandomnelementswithnorepetition">Selecting Random n Elements with No Repetition</h2>
If you're looking to create random collections of n elements, with no repetitions, the task is seemingly more complex than the previous tasks, but in practice - it's pretty simple.
You <code>shuffle()</code> the list and partition it into n parts. This ensures that no duplicate elements are added, since you're just slicing the list, and we've shuffled it so the collections are random.
<blockquote>
If you'd like to read more about splitting a list into random chunks take a look at - <a target="_blank" href="https://stackabuse.com/how-to-split-a-list-into-even-chunks-in-python/">How to Split a List Into Even Chunks in Python</a>.
</blockquote>
We'll save the result in a new list, and if there's not enough elements to fit a final collection, it'll simply be unfinished:
<pre><code class="hljs">import random

def select_random_Ns(lst, n):
 random.shuffle(lst)
 result = []
 for i in range(0, len(lst), n):
 result.append(lst[i:i + n])
 return result
 
 
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]

print(select_random_Ns(lst, 2))
</code></pre>
This results in a list of random pairs, without repetition:
<pre><code class="hljs">[[8, 6], [3, 4], [5, 7], [9, 1], [2]]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've explored several ways to retrieve one or multiple randomly selected elements from a List in Python.
We've accessed the list in random indices using <code>randint()</code> and <code>randrange()</code>, but also got random elements using <code>choice()</code> and <code>sample()</code>.

In this article, we'll take a look at *how to randomly select elements from a list in Python* - both singular random elements, as well as multiple elements - with and without repetition.

How to Randomly Select Elements From a List in Python 

How to Randomly Select Elements from a List in Python

<h2 id="introduction">Introduction</h2>
Updating Python packages can be a hassle. There are many of them - it's hard to keep track of all the newest versions, and even when you decide what to update, you still have to update each of them manually.
To address this issue, <a rel="nofollow noopener" target="_blank" href="https://pypi.org/project/pip-review/">pip-review</a> was created. It lets you smoothly manage all available <a rel="nofollow noopener" target="_blank" href="https://pypi.org/">PyPi </a> updates with simple commands.
Originally a part of the <code>pip-tools</code> package, it now lives on as a standalone convenience wrapper around <code>pip</code>. In this tutorial, we'll be covering how to update all packages with pip-review.
<h2 id="installpipreview">Install pip-review</h2>
You can install <code>pip-review</code> in a virtual environment, if you'd like to contain it, or system-wide. Naturally, installing <code>pip-review</code> is done via <code>pip</code>:
<pre><code class="hljs">$ pip install pip-review
...
Successfully installed pip-review-1.1.0
</code></pre>
<h2 id="helppageofpipreview">Help Page of pip-review</h2>
If you forget any of these commands or you simply want an overview of the command options:
<pre><code class="hljs">$ pip-review -h
usage: pip-review [-h] [--verbose] [--raw] [--interactive] [--auto]

Keeps your Python packages fresh. Looking for a new maintainer! See https://github.com/jgonggrijp/pip-review/issues/76

optional arguments:
 -h, --help show this help message and exit
 --verbose, -v Show more output
 --raw, -r Print raw lines (suitable for passing to pip install)
 --interactive, -i Ask interactively to install updates
 --auto, -a Automatically install every update found

Unrecognised arguments will be forwarded to pip list --outdated and pip install, so you can pass things such as --user, --pre and --timeout and they will do what you expect. See pip list -h and pip install -h
for a full overview of the options.
</code></pre>
<h2 id="checkallpackageversionswithpipreview">Check All Package Versions with pip-review</h2>
Sometimes, you'd just want to check if there are any updates, before committing to a potentially long update list. To check all package versions, you simply run:
<pre><code class="hljs">$ pip-review
scikit-learn==0.23.2 is available (you have 0.23.1)
scipy==1.5.4 is available (you have 1.4.1)
seaborn==0.11.0 is available (you have 0.10.1)
...
</code></pre>
This gives you a report that lists all available package updates. Essentially, it calls <code>pip list – outdated</code>. This has the advantage of allowing you to decide which packages you'd like to update, if any at all.
<h2 id="updateallpackageswithpipreview">Update All Packages with pip-review</h2>
Once you've identified if you'd like to update your packages, you can update them all, automatically, using:
<pre><code class="hljs">$ pip-review --auto
Collecting beautifulsoup4==4.9.3
Downloading beautifulsoup4-4.9.3-py3-none-any.whl (115 kB)
...
</code></pre>
Running just this command alone - you're set to go. It's that simple.
<h2 id="updateallpackagesinteractivelywithpipreview">Update All Packages Interactively with pip-review</h2>
If you perhaps don't wish to update some specific packages, you don't need to run the <code>--auto</code> updater. If you launch the process as <code>--interactive</code>, you can choose for each individual package whether you'd like to update it or no:
<pre><code class="hljs">$ pip-review --interactive
matplotlib==3.3.3 is available (you have 3.1.3)
Upgrade now? [Y]es, [N]o, [A]ll, [Q]uit N
numpy==1.19.4 is available (you have 1.18.1)
Upgrade now? [Y]es, [N]o, [A]ll, [Q]uit Y
pandas==1.1.5 is available (you have 1.0.3)
Upgrade now? [Y]es, [N]o, [A]ll, [Q]uit N
...
</code></pre>
For each package, you have four options available, &quot;Yes&quot;, &quot;No&quot;, &quot;All&quot; and &quot;Quit&quot;.
Selecting &quot;Yes&quot; indicates you want that particular package added to the &quot;to-be-updated-list&quot;. At the end every package on this list gets updated.
If you end up selecting &quot;No&quot; it would mean the package won't get updated. Selecting &quot;All&quot; means all packages moving forward will be added to the list. Finally, selecting &quot;Quit&quot; would mean <code>pip-review</code> will skip all remaining packages and update only the ones you selected &quot;Yes&quot; to.
<h2 id="preventpipreviewfromupdatingcertainpackages">Prevent pip-review from Updating Certain Packages</h2>
In some situations, you might want to prevent certain packages from automatically updating when running <code>pip-review --auto</code>. This could be perhaps to avoid dependency issues, a common problem.
In these cases, you'd want to pin the specific packages that you don't want to update. You can do this via a <a rel="nofollow noopener" target="_blank" href="https://pip.pypa.io/en/stable/user_guide/#constraints-files">constraint file</a>. A constraint file is a requirement file that only controls which version of a requirement is installed, not whether it is installed or not.
Its syntax and contents are identical to that of requirement files. There is one key difference:
<blockquote>
Including a package in a constraints file doesn't trigger installation of the package.
</blockquote>
Let's make a <code>constraints.txt</code> file:
<pre><code class="hljs">$ export PIP_CONSTRAINT=&quot;/home/username/constraints.txt
</code></pre>
And now within it, we'll insert:
<pre><code class="hljs">matplotlib==3.1.3
pandas==1.0.3
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Updating packages using <code>pip</code> can be tedious and time-consuming. And as expected in the computer science world, a tool was born to automate this. In this article, we've gone over the <code>pip-review</code> utility - how to install it, as well as how to use it to update packages in Python.

Daniel Pimeh

In this tutorial, we'll be going over a great simple tool - pip-review, to automatically update all Python packages.

Python: Update All Packages With pip-review

Python: Update All Packages with pip-review

<h2 id="introduction">Introduction</h2>
When working with dates, oftentimes, you'd like to know if a given date comes before or after another date. We can get these answers by comparing dates.
In this article, we will learn how to use the Python <code>datetime</code> module to create and compare both naive (without timezone info) and aware (with timezone info) dates.
To compare the dates, we will use the comparison operators in Python: <code>&lt;, &gt;, ==, &lt;=, &gt;=, !=</code>.
Note: The <code>datetime</code> module has two methods for creating dates object - <code>datetime.datetime</code> and <code>datetime.date</code>. Comparisons can only be made on objects created from the same class:
<pre><code class="hljs">datetime.datetime.now() &gt;= datetime.date.today()
</code></pre>
This will result in a <code>TypeError</code>:
<pre><code class="hljs">TypeError: can&#x27;t compare datetime.datetime to datetime.date
</code></pre>
<h2 id="comparingtimezonenaivedatetimes">Comparing Timezone-Naive Datetimes</h2>
Let's start off with comparing naive dates, which don't have any timezone information. First, we'll want to import the <code>datetime</code> module:
<pre><code class="hljs">from datetime import datetime, date
</code></pre>
Then, let's make a few dates that we can compare:
<pre><code class="hljs">date1 = date(1995, 3, 20)
date2 = date(2020, 1, 1)
dob_a = datetime(1995, 3, 20)
dob_b = datetime(2020, 1, 1)
</code></pre>
Comparing these objects is made as easy as comparing, say, integers. A date is less than another, if its time precedes the other.
In our case, <code>date1</code> is considered less (<code>&lt;</code>) than <code>date2</code> because it's farther back in time:
<pre><code class="hljs">print(&quot;date1 comes before date2?&quot;, date1 &lt; date2)
print(&quot;date1 comes after date2?&quot;, date1 &gt; date2)
print(&quot;date1 is equal to date2?&quot;, date1 == date2)
</code></pre>
This results in:
<pre><code class="hljs">date1 comes before date2? True
date1 comes after date2? False
date1 is equal to date2? False
</code></pre>
Now, you'd typically incorporate this logic into some flow-control statements:
<pre><code class="hljs">if dob_a &gt; dob_b:
 print(&quot;person a is older than person b&quot;)
else:
 print(&quot;person b is older than person a&quot;)
</code></pre>
This results in:
<pre><code class="hljs">person b is older than person a
</code></pre>
<h2 id="comparingtimezoneawaredatetimes">Comparing Timezone-Aware Datetimes</h2>
Time zones can complicate things a bit, though, thankfully, we can apply the exact same logic to the comparison. The only difference is that we're working with aware dates - dates with additional information about the time zone they're in:
<pre><code class="hljs">from datetime import datetime
import pytz

# Create timezone objects for different parts of the world
tz_ny= pytz.timezone(&#x27;America/New_York&#x27;)
tz_lon = pytz.timezone(&quot;Europe/London&quot;)

# Year, Month, Day, Hour, Minute, Second
datetime = datetime(2010, 4, 20, 23, 30, 0)

# Localize the given date, according to the timezone objects
date_with_timezone_1 = tz_ny.localize(datetime)
date_with_timezone_2 = tz_lon.localize(datetime)

# These are now, effectively no longer the same *date* after being localized
print(date_with_timezone_1) # 2010-04-20 23:30:00-04:00
print(date_with_timezone_2) # 2010-04-20 23:30:00+01:00

print(date_with_timezone_1 == date_with_timezone_2)
</code></pre>
Running this code results in:
<pre><code class="hljs">False
</code></pre>
While this statement:
<pre><code class="hljs">print(date_with_timezone_1 &gt; date_with_timezone_2)
</code></pre>
Would result in:
<pre><code class="hljs">True
</code></pre>
Now, this result might strike you as a bit odd. We're comparing these two datetimes:
<pre><code class="hljs">2010-04-20 23:30:00-04:00 # date_with_timezone_1
2010-04-20 23:30:00+01:00 # date_with_timezone_2
</code></pre>
Intuitively, it looks like <code>date_with_timezone_2</code> is indeed larger than <code>date_with_timezone_1</code>. Though, let's take a look at how the <code>localize()</code> function works.
Here, we've used the <code>pytz</code> library to make our naive dates aware. We've constructed a timezone object for New York (<code>tz_ny</code>), and a timezone object for London (<code>tz_lon</code>).
Then, to inject timezone information into our <code>datetime</code> object, we've run the <code>localize()</code> function and packed the result into <code>date_with_timezone_1</code> and <code>date_with_timezone_2</code>.
We've put in 11:30PM into <code>localize()</code>, which in turn created a datetime for 11:30PM in New York, and 11:30PM in London respectively. To get from 11:30PM in New York, to 11:30PM in London, you'd have to add 4 hours. More time has passed to get New York to 11:30PM, than it took to get London to 11:30PM. Thus, the datetime corresponding to New York at 11:30PM is larger than the datetime corresponding to London at 11:30PM.
Please keep this behavior in mind when working with timezones this way.
However, it is worthy of note that comparing aware dates with naive dates will result in an error:
<pre><code class="hljs">date_with_timezone = tz_ny.localize(datetime)
print(datetime == date_without_timezone)
</code></pre>
This will result in the following error:
<pre><code class="hljs">TypeError: can't compare offset-naive and offset-aware datetimes
</code></pre>
So to compare datetime objects, both objects must both be either naive or aware.
<h2 id="conclusion">Conclusion</h2>
In this article, we have discussed ways of comparing both timezone-aware and timezone-naive dates in Python, we have also looked at possible pitfalls that we may encounter when comparing dates and possible workarounds.
If you have any questions or contributions please leave them in the comments section below.

Geoffery, Joseph

In this tutorial, we'll go over how to compare dates in Python, with and without timezones, using pytz, with examples.