Skip to content

Learn Python Control Flow and Loops to Write and Tune Shell Scripts – Part 2

learn python control flow and loops indiancyberdude

In the previous article of this Python series, we shared a brief introduction to Python, its command-line shell, and the IDLE.

In this tutorial, we covered essential concepts of programming, including arithmetic calculations, variable storage, and printing values to the screen. Additionally, we provided a practical example to explain methods and properties within the context of Object Oriented Programming. Follow along to strengthen your foundational understanding of programming.

This guide will cover essential programming concepts such as control flow and loops. We’ll explore how to make decisions based on user input, calculation results, or variable values, as well as how to automate repetitive tasks. Using this knowledge, we’ll create a shell script that displays crucial system information such as the operating system type, hostname, kernel release, version, and machine hardware name. Follow along to learn how to improve your coding skills and create efficient scripts for your projects.

This example, although basic, will help us illustrate how we can leverage Python OOP’s capabilities to write shell scripts easier than using regular bash tools.

In other words, we want to go from

# uname -snrvm
Check Hostname of Linux
Check the Hostname of the Linux


Check Linux Hostname Using Python Script
Check Linux Hostname Using Python Script


Script to Check Linux System Information
Script to Check Linux System Information

Looks pretty, doesn’t it? Let’s roll up our sleeves and make it happen.

Learn Control Flow in Python

As we said earlier, control flow allows us to choose different outcomes depending on a given condition. Its most simple implementation in Python is an if / else clause.

The basic syntax is:

if condition:
    # action 1
    # action 2
  • When the condition evaluates to true, the code block below will be executed (represented by # action 1. Otherwise, the code under else will be run.
  • A condition can be any statement that can evaluate as either true or false.

For example:

1 < 3 # true
firstName == "Gabriel" # true for me, false for anyone not named Gabriel
  • In the first example, we compared two values to determine if one is greater than the other.
  • In the second example we compared firstName (a variable) to determine if, at the current execution point, its value is identical to “Gabriel
  • The condition and the else statement must be followed by a colon (:)
  • Indentation is important in Python. Lines with identical indentation are considered to be in the same code block.

Please note that the if / else statement is only one of the many control flow tools available in Python. We reviewed it here since we will use it in our script later. You can learn more about the rest of the tools in the official docs.

Learn Loops in Python

Simply put, a loop is a sequence of instructions or statements that are executed in order as long as a condition is true, or once per item in a list.

The most simple loop in Python is represented by the for loop that iterates over the items of a given list or a string beginning with the first item and ending with the last.

Basic syntax:

for x in example:
	# do this

Here example can be either a list or a string. If the former, the variable named x represents each item in the list; if the latter, x represents each character in the string:

>>> rockBands = []
>>> rockBands.append("Roxette")
>>> rockBands.append("Guns N' Roses")
>>> rockBands.append("U2")
>>> for x in rockBands:
>>> firstName = "Gabriel"
>>> for x in firstName:

The output of the above examples is shown in the following image:

Learn Loops in Python
Learn Loops in Python

Python Modules

For obvious reasons, there must be a way to save a sequence of Python instructions and statements in a file that can be invoked when it is needed.

That is precisely what a module is. Particularly, the os module provides an interface to the underlying operating system and allows us to perform many of the operations we usually do in a command-line prompt.

As such, it incorporates several methods and properties that can be called as we explained in the previous article. However, we need to import (or include) it in our environment using the import keyword:

>>> import os

Let’s print the current working directory:

>>> os.getcwd()
Learn Python Modules
Learn Python Modules

Let’s now put all of this together (along with the concepts discussed in the previous article) to write the desired script.

Python Script

It is considered good practice to start a script with a statement that indicates the purpose of the script, the license terms under which it is released, and a revision history listing the changes that have been made. Although this is more of a personal preference, it adds a professional touch to our work.

Here’s the script that produces the output we have shown at the top of this article. It is heavily commented on so that you can understand what’s happening.

Take a few minutes to go through it before proceeding. Note how we use an if / else structure to determine whether the length of each field caption is greater than the value of the field itself.

Based on the result, we use empty characters to fill in the space between a field caption and the next. Also, we use the right number of dashes as a separator between the field caption and its value below.

# Change the above line to #!/usr/bin/python if you don't have Python 3 installed

# Script name:
# Purpose: Illustrate Python's OOP capabilities to write shell scripts more easily
# License: GPL v3 (

# Copyright (C) 2016 Gabriel Alejandro Cánepa
# ​Facebook / Skype / G+ / Twitter / Github: gacanepa
# Email: gacanepa (at) gmail (dot) com

# This program is free software: you can redistribute it and/or modify
# it is under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <>.

# ---------- ------- --------------
# 2016-05-28 1.0     Gabriel Cánepa    Initial version

# Import the os module
import os

# Assign the output of os.uname() to the the systemInfo variable
# os.uname() returns a 5-string tuple (sysname, nodename, release, version, machine)
# Documentation:
systemInfo = os.uname()

# This is a fixed array with the desired captions in the script output
headers = ["Operating system","Hostname","Release","Version","Machine"]

# Initial value of the index variable. It is used to define the
# index of both systemInfo and headers in each step of the iteration.
index = 0

# Initial value of the caption variable.
caption = ""

# Initial value of the values variable
values = ""

# Initial value of the separators variable
separators = ""

# Start of the loop
for item in systemInfo:
    if len(item) < len(headers[index]):
   	 # A string containing dashes to the length of item[index] or headers[index]
   	 # To repeat a character(s), enclose it within quotes followed
   	 # by the star sign (*) and the desired number of times.
   	 separators = separators + "-" * len(headers[index]) + " "
   	 caption = caption + headers[index] + " "
   	 values = values + systemInfo[index] + " " * (len(headers[index]) - len(item)) + " "
   	 separators = separators + "-" * len(item) + " "
   	 caption =  caption + headers[index] + " " * (len(item) - len(headers[index]) + 1)
   	 values = values + item + " "
    # Increment the value of index by 1
    index = index + 1
# End of the loop

# Print the variable named caption converted to uppercase

# Print separators

# Print values (items in systemInfo)

# 1) Save the script as (or another name of your choosing) and give it execute permissions:
# chmod +x
# 2) Execute it:
# ./

Once you have saved the above script to a file, give it execute permissions and run it as indicated at the bottom of the code:

# chmod +x
# ./

If you get the following error while attempting to execute the script:

-bash: ./ /usr/bin/python3: bad interpreter: No such file or directory

It means you don’t have Python 3 installed. If that is the case, you can either install the package or replace the interpreter line (pay special attention and be very careful if you followed the steps to update the symbolic links to the Python binaries as outlined in the previous article):




which will cause the installed version of Python 2 to execute the script instead.

Note: This script has been tested successfully both in Python 2.x and 3.x.

Although somewhat rudimentary, you can think of this script as a Python module. This means that you can open it in the IDLE (File → Open… → Select file):

Open Python in IDLE
Open Python in IDLE

A new window will open with the contents of the file. Then go to Run → Run module (or just press F5). The output of the script will be shown in the original shell:

Run Python Script
Run Python Script

If you want to obtain the same results with a script written purely in Bash, you would need to use a combination of awk, sed, and resort to complex methods to store and retrieve items in a list (not to mention the use of tr to convert lowercase letters to uppercase).

In addition, Python provides portability in that all Linux systems ship with at least one Python version (either 2.x or 3.x, sometimes both). Should you need to rely on a shell to accomplish the same goal, you would need to write different versions of the script based on the shell.

This goes to show that Object Oriented Programming features can become strong allies of system administrators.

Note: You can find this python script (and others) in one of my GitHub repositories.


This article covers the fundamentals of Python programming, including control flow, loops, iteration, and modules. It also highlights the benefits of using object-oriented programming (OOP) techniques and properties in Python to streamline complex shell scripts. Keep reading to learn more about optimizing your Python code with these essential concepts.

Looking for more ways to experiment with Python? We encourage you to try writing your own scripts and see what you can create. If you have any questions or need assistance, please don’t hesitate to contact us using the comment form below. We are always here to help and will respond to your inquiry as soon as possible.

Leave a Reply

Your email address will not be published. Required fields are marked *