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

Guest Contributor

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.

Comparing Datetimes in Python - With and Without Timezones

Comparing Datetimes in Python with and without Timezones

<h2 id="introduction">Introduction</h2>
Strings are a handy way of getting information across and getting input from a user.
In this article, we will go through a couple of ways check if a String is Numeric in Java - that is to say, if a String represents a numeric value.
<h2 id="checkifstringisnumericwithcorejava">Check if String is Numeric with Core Java</h2>
Users tend to mistype input values fairly often, which is why developers have to hold their hand as much as possible during IO operations.
The easiest way of checking if a <code>String</code> is a numeric or not is by using one of the following built-in Java methods:
<ol>
<li><code>Integer.parseInt()</code></li>
<li><code>Integer.valueOf()</code></li>
<li><code>Double.parseDouble()</code></li>
<li><code>Float.parseFloat()</code></li>
<li><code>Long.parseLong()</code></li>
</ol>
These methods convert a given <code>String</code> into its numeric equivalent. If they can't convert it, a <code>NumberFormatException</code> is thrown, indicating that the String wasn't numeric.
It's worth noting that <code>Integer.valueOf()</code> returns a <code>new Integer()</code>, while <code>Integer.parseInt()</code> returns a primitive <code>int</code>. Keep this in mind if such a difference would change the flow of your program.
Let's try this out:
<pre><code class="hljs">String string = &quot;10&quot;;

try {
 intValue = Integer.parseInt(string);
 return true;
} catch (NumberFormatException e) {
 System.out.println(&quot;Input String cannot be parsed to Integer.&quot;);
}
</code></pre>
This results in:
<pre><code class="hljs">true
</code></pre>
Now, we can abstract this functionality into a helper method for convenience:
<pre><code class="hljs">public static boolean isNumeric(String string) {
 int intValue;
 
 System.out.println(String.format(&quot;Parsing string: \&quot;%s\&quot;&quot;, string));
 
 if(string == null || string.equals(&quot;&quot;)) {
 System.out.println(&quot;String cannot be parsed, it is null or empty.&quot;);
 return false;
 }
 
 try {
 intValue = Integer.parseInt(string);
 return true;
 } catch (NumberFormatException e) {
 System.out.println(&quot;Input String cannot be parsed to Integer.&quot;);
 }
 return false;
}
</code></pre>
Now, we can simply call:
<pre><code class="hljs">String string = &quot;10&quot;;

if(isNumeric(string)) { 
 System.out.println(&quot;String is numeric!&quot;);
 // Do something
} else {
 System.out.println(&quot;String is not numeric.&quot;);
}
</code></pre>
Running this code would result in:
<pre><code class="hljs">Parsing string: &quot;10&quot;
String is numeric!
</code></pre>
On the other hand, if we expect the <code>String</code> to contain a really big number, then we can call the <code>BigInteger(String)</code> constructor, which translates the <code>String</code> representation into a <code>BigInteger</code>.
<h2 id="checkifstringisnumericwithapachecommons">Check if String is Numeric with Apache Commons</h2>
<a rel="nofollow noopener" target="_blank" href="https://commons.apache.org/">Apache Commons</a> is one of the most used third-party libraries for expanding the basic Java Framework. It gives us more fine control over core Java classes, in this case, Strings.
We'll be looking at two classes from the Apache Commons library:
<ol>
<li><code>NumberUtils</code></li>
<li><code>StringUtils</code></li>
</ol>
Both of which are very similar to their vanilla Java class counterparts, but with an emphasis on null-safe operations (on numbers and strings respectively), meaning we can even define default values for missing (null) values.
Let's now take a look at how we can check for numeric values using these methods.
<h3 id="numberutilsisparsable">NumberUtils.isParsable()</h3>
This method accepts a <code>String</code> and checks if it's a parsable number or not, we can be use this method instead of catching an exception when calling one of the methods we mentioned earlier.
This is very good because solutions that involve frequent exception handling should be avoided if possible - this is exactly what this method helps us with.
<blockquote>
Note that hexadecimal numbers and scientific notations are not considered parsable.
</blockquote>
Now, we don't really even need a convenience helper method, as <code>isParseable()</code> returns a <code>boolean</code> itself:
<pre><code class="hljs">String string = &quot;10&quot;;

if (NumberUtils.isParsable(string)) {
 System.out.println(&quot;String is numeric!&quot;);
} else {
 System.out.println(&quot;String is not numeric.&quot;);
}
</code></pre>
This code should return:
<pre><code class="hljs">String is numeric!
</code></pre>
<h3 id="numberutilsiscreatable">NumberUtils.isCreatable()</h3>
This method also accepts a String and checks if it's a valid Java number. With this method we can cover even more numbers, because a valid Java number includes even hexadecimal and octal numbers, scientific notation, as well as numbers marked with a type qualifier.
Now, we can even use something along the lines of:
<pre><code class="hljs">String string = &quot;0x10AB&quot;;

if (NumberUtils.isCreatable(string)) {
 System.out.println(&quot;String contains a creatable number!&quot;);
} else {
 System.out.println(&quot;String doesn&#x27;t contain creatable number.&quot;);
}
</code></pre>
The output would be:
<pre><code class="hljs">String contains a creatable number!
</code></pre>
<h3 id="numberutilsisdigits">NumberUtils.isDigits()</h3>
The <code>NumberUtils.isDigits()</code> method checks if a string contains only Unicode digits. If the <code>String</code> contains a leading sign or decimal point the method will return <code>false</code>:
<pre><code class="hljs">String string = &quot;25&quot;;

if (NumberUtils.isDigits(string)) {
 System.out.println(&quot;String is numeric!&quot;);
} else {
 System.out.println(&quot;String isn&#x27;t numeric.&quot;);
}
</code></pre>
<h3 id="stringutilsisnumeric">StringUtils.isNumeric()</h3>
The <code>StringUtils.isNumeric()</code> is the <code>StringUtils</code> equivalent of <code>NumberUtils.isDigits()</code>.
<blockquote>
If the <code>String</code> passes the numeric test, it may still generate a <code>NumberFormatException</code> error when parsed by the methods we mentioned earlier, for example if it is out of range for <code>int</code> or <code>long</code>.
</blockquote>
Using this method we can determine if we can parse <code>String</code> into an <code>Integer</code>:
<pre><code class="hljs">String string = &quot;25&quot;;

if (StringUtils.isNumeric(string)) {
 System.out.println(&quot;String is numeric!&quot;);
} else {
 System.out.println(&quot;String isn&#x27;t numeric.&quot;);
}
</code></pre>
<h3 id="stringutilsisnumericspace">StringUtils.isNumericSpace()</h3>
Additionally, if we expect to find more numbers within a String, we can use <code>isNumericSpace</code>, another useful <code>StringUtils</code>method worth mentioning. It checks if the <code>String</code> contains only Unicode digits or spaces.
Let's check a String that contains numbers and spaces:
<pre><code class="hljs">String string = &quot;25 50 15&quot;;

if (StringUtils.isNumericSpace(string)) {
 System.out.println(&quot;String is numeric!&quot;);
} else {
 System.out.println(&quot;String isn&#x27;t numeric.&quot;);
}
</code></pre>
This results in:
<pre><code class="hljs">String is numeric!
</code></pre>
<h2 id="checkifstringisnumericwithregex">Check if String is Numeric with Regex</h2>
Even though most developers will be content with using an already implemented method, sometimes you might have very specific pattern checking:
<pre><code class="hljs">public static boolean isNumeric(String string) {
 // Checks if the provided string
 // is a numeric by applying a regular
 // expression on it.
 String regex = &quot;[0-9]+[\\.]?[0-9]*&quot;;
 return Pattern.matches(regex, string);
}
</code></pre>
And then, we can call this method:
<pre><code class="hljs">System.out.println(&quot;123: &quot; + isStringNumeric2(&quot;123&quot;));
System.out.println(&quot;I&#x27;m totally a numeric, trust me: &quot; + isStringNumeric2(&quot;I&#x27;m totally a numeric, trust me&quot;));
</code></pre>
Running this gives us the following output:
<pre><code class="hljs">123: true
I&#x27;m totally a numeric, trust me: false
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've covered several ways to check if a String is numeric or not (represents a number) in Java.
We've started off using Core Java, and catching a <code>NumberFormatException</code>, after which we've used the Apache Commons library. From there, we've utilized the <code>StringUtils</code> and <code>NumberUtils</code> classes to check whether a String is numeric or not, with various formats.

Anđela Niketić

In this tutorial, we'll go over examples on how to check if a String represents a Number in Java. We'll use Core Java and the Apache Commons Library, as well as Regex.

Java: Check if String is a Number

<h2 id="introduction">Introduction</h2>
Python is a very high-level programming language, and it tends to stray away from anything remotely resembling internal data structure. Because of this, we usually don't really need indices of a list to access its elements, however, sometimes we desperately need them.
In this article, we will go over different approaches on how to access an index in Python's for loop.
<h2 id="howtoaccessindexinpythonsforloop">How to Access Index in Python's for Loop?</h2>
The easiest, and most popular method to access the index of elements in a for loop is to go through the list's length, increasing the <code>index</code>. On each increase, we access the list on that <code>index</code>:
<pre><code class="hljs">my_list = [3, 5, 4, 2, 2, 5, 5]

print(&quot;Indices and values in my_list:&quot;)

for index in range(len(my_list)):
 print(index, my_list[index], end = &quot;\n&quot;)
</code></pre>
Here, we don't iterate through the list, like we'd usually do. We iterate from <code>0..len(my_list)</code> with the <code>index</code>. Then, we use this <code>index</code> variable to access the elements of the list in order of <code>0..n</code>, where <code>n</code> is the end of the list.
This code will produce the output:
<pre><code class="hljs">Indices and values in my_list:
0 3
1 5
2 4
3 2
4 2
5 5
6 5
</code></pre>
<h2 id="usingenumerate">Using enumerate()</h2>
<code>enumerate()</code> is a built-in Python function which is very useful when we want to access both the values and the indices of a list. It's worth noting that this is the fastest and most efficient method for acquiring the index in a for loop.
This method adds a counter to an iterable and returns them together as an enumerated object. This enumerate object can be easily converted to a list using a <code>list()</code> constructor. This is the most common way of accessing both elements and their indices at the same time.
Now, let's take a look at the code which illustrates how this method is used:
<pre><code class="hljs">my_list = [3, 5, 4, 2, 2, 5, 5]
print(&quot;Indices and values in my_list:&quot;) 
for index, value in enumerate(my_list): 
 print(list((index, value))) 
</code></pre>
This code will produce the output:
<pre><code class="hljs">Indices and values in my_list:
[0, 3]
[1, 5]
[2, 4]
[3, 2]
[4, 2]
[5, 5]
[6, 5]
</code></pre>
What we did in this example was enumerate every value in a list with its corresponding index, creating an enumerate object. Then, we converted that enumerate object into a list using the <code>list()</code> constructor, and printed each list to the standard output.
Additionally, you can set the <code>start</code> argument to change the indexing. Currently, it's 0-based. Let's change it to start at <code>1</code> instead:
<pre><code class="hljs">my_list = [3, 5, 4, 2, 2, 5, 5]
print(&quot;Indices and values in my_list:&quot;) 
for index, value in enumerate(my_list, start=1): 
 print(list((index, value))) 
</code></pre>
Now, this produces:
<pre><code class="hljs">Indices and values in my_list:
[1, 3]
[2, 5]
[3, 4]
[4, 2]
[5, 2]
[6, 5]
[7, 5]
</code></pre>
<h2 id="usinglistcomprehensions">Using List Comprehensions</h2>
A list comprehension is a way to define and create lists based on already existing lists. It's usually a faster, more elegant, and compact way to manipulate lists, compared to functions and <code>for</code> loops.
Every list comprehension in Python contains these three elements:
<ol>
<li>iterable - A collection who's elements we can inspect one at a time</li>
<li>member - Value or object in a list (which is an iterable)</li>
<li>expression - Can be any valid expression that returns a value(a member, an iterable, a call to a function...)</li>
</ol>
Let's take a look at the following example:
<pre><code class="hljs">my_list = [1, 2, 3, 4, 5]
my_list_squared = [m*m for m in my_list]
print(my_list_squared)
</code></pre>
This code will produce the output:
<pre><code class="hljs">[1, 4, 9, 16, 25]
</code></pre>
In this list comprehension, <code>my_list</code> represents the iterable, <code>m</code> represents a member and <code>m*m</code> represents the expression.
Now that we went through what list comprehension is, we can use it to iterate through a list and access its indices and corresponding values. Let's take a look at this example:
<pre><code class="hljs">my_list = [3, 5, 4, 2, 2, 5, 5]
print(&quot;Indices and values in my_list:&quot;) 
print([list((i, my_list[i])) for i in range(len(my_list))])
</code></pre>
This code will produce the output:
<pre><code class="hljs">Indices and values in my_list:
[[0, 3], [1, 5], [2, 4], [3, 2], [4, 2], [5, 5], [6, 5]]
</code></pre>
What we did in this example was use the <code>list()</code> constructor. This constructor takes no arguments or a single argument - an iterable. This includes any object that could be a sequence (string, tuples) or a collection (set, dictionary).
If no parameters are passed, it returns an empty list, and if an iterable is passed as a parameter it creates a list consisting of its items.
We constructed a list of two element lists which are in the format <code>[elementIndex, elementValue]</code> . These two-element lists were constructed by passing pairs to the <code>list()</code> constructor, which then spat an equivalent list.
This will create 7 separate lists containing the index and its corresponding value in <code>my_list</code> that will be printed.
<h2 id="usingzip">Using zip()</h2>
The <code>zip()</code> function accepts two or more parameters, which all must be iterable.
It returns a zip object - an iterator of tuples in which the first item in each passed iterator is paired together, the second item in each passed iterator is paired together, and analogously for the rest of them:
<pre><code class="hljs">list_a = [1, 2, 3]
list_b = [&#x27;A&#x27;, &#x27;B&#x27;, &#x27;C&#x27;]

# Zip will make touples from elements with the same 
# index (position in the list). Meaning that 1 from the
# first list will be paired with &#x27;A&#x27;, 2 will be paired
# with &#x27;B&#x27; and so on...
for elem1,elem2 in zip(list_a,list_b):
 print((elem1,elem2))
</code></pre>
Running the code snippet above we get:
<pre><code class="hljs">(1, 'A')
(2, 'B')
(3, 'C')
</code></pre>
The length of the iterator that this function returns is equal to the length of the smallest of its parameters.
Now that we've explained how this function works, let's use it to solve our task:
<pre><code class="hljs">my_list = [3, 5, 4, 2, 2, 5, 5]
print (&quot;Indices and values in my_list:&quot;) 
for index, value in zip(range(len(my_list)), my_list):
 print((index, value))
</code></pre>
This code will produce the output:
<pre><code class="hljs">Indices and values in my_list:
(0, 3)
(1, 5)
(2, 4)
(3, 2)
(4, 2)
(5, 5)
(6, 5)
</code></pre>
In this example, we passed a sequence of numbers in the range from <code>0</code> to <code>len(my_list)</code> as the first parameter of the <code>zip()</code> function, and <code>my_list</code> as its second parameter. The function paired up each index with its corresponding value, and we printed them as tuples using a <code>for</code> loop.
If we wanted to convert these tuples into a list, we would use the <code>list()</code> constructor, and our <code>print</code> function would look like this:
<pre><code class="hljs">print(list((index, value)))
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article we went through four different methods that help us access an index and its corresponding value in a Python list.
Besides the most basic method, we went through the basics of list comprehensions and how they can be used to solve this task. Even though it's a faster way to do it compared to a generic for loop, we should generally avoid using it if the list comprehension itself becomes far too complicated. Complicated list comprehensions can lead to a lot of messy code.
It is important to note that even though every list comprehension can be rewritten in a for loop, not every for loop can be rewritten into a list comprehension.
Another two methods we used were relying on the Python in-built functions: <code>enumerate()</code> and <code>zip()</code>, which joined together the indices and their corresponding values into tuples. Then, we converted those tuples into lists and printed them on the standard output.

Mila Lukic

In this tutorial, we'll go over how to access the index in a Python's for loop. We'll use a generic manual approach, as well as use enumerations, the zip() function and list comprehensions.

How to Access Index in Python's for Loop

Ruslan Hasanov

In this tutorial, we will combine DataFrames in Pandas using the merge function. We will also merge data with join, append, concat, combine_first and update, with examples.