Introduction Loops in Python
A concept in Python programming package that allows repetition of certain steps, or printing or execution of the similar set of steps repetitively, based on the keyword that facilitates such functionality being used, and that steps specified under the keyword automatically indent accordingly is known as loops in python. It is acting as a block, with “while” continuing to execute until a certain specified condition is met and “for” executing till the index variable in the specified range of values reaches its final value.
Looping is a common phenomenon in any programming language; From a python perspective, the powerful programming language offers two broad categories of loops.
They are as below:
- While Loops
- For loops
The common strategy behind while loops are they execute a set of statements until the given condition is satisfied. The next statement call happens at the instance when the specified condition is satisfied. The use of indented code segments determines the segment or the body of the loop. Indentation starts the loop, and the line from which it starts to be unindented represents the end of the mentioned loop. All non-zero values are interpreted as true here.
n = 10 sum = 0 i = 1 while i <= n: sum = sum + i i = i+1 print("The sum is", sum)
While Loop Example
Python Program for Matching a String
- import string
- import random
- import time
endeavourNext = '' completed = False iterator = 0
Propable Characters to Compare
propableCharacters = string.ascii_lowercase + string.digits + string.ascii_uppercase + ' ., !?;:'
String to Be Generated
t = input("Enter the expected string or word : ")
Generate the Initial Random String
endeavourThis = ''.join(random.choice(propableCharacters)
for i in range(len(t)))
Iterate While Completed Is False
Increment the iterator
iterator += 1 endeavourThis = endeavourNext time.sleep(0.1)
print("Target match found after " +
str(iterator) + " iterators")
For traversing a sequential statement set, these loops are implied. The persistence of the loop is passed on pending the last item in the series is executed. While loop here to the content of the loop is separated from the rest of the code by introducing the indentation. As like while loop here to indentation plays an important role in determining the body of the loop involved. Indentation starts the loop, and the line from which it starts to be unindented represents the end of the mentioned loop.
for iterator_var in sequence:
For Loop Example#1
Python Program Using Turtle Graphing Technique
def border(obj1, panel_x, panel_y): obj1.penup() obj1.home() obj1.forward(panel_x / 2) obj1.right(90) obj1.forward(panel_y / 2) obj1.setheading(180) obj1.pencolor('red') obj1.pendown() obj1.pensize(10) for distance in (panel_x, panel_y, panel_x, panel_y): obj1.forward(distance) obj1.right(90) obj1.penup() obj1.home() def square(obj1, size, color): obj1.pencolor(color) obj1.pendown() for i in range(4): obj1.forward(size) obj1.right(90) def main(): panel = turtle.Screen() panel.title('Square Demo') panel_x, panel_y = panel.screensize() obj1 = turtle.Turtle() border(obj1, panel_x, panel_y) colors = ['red', 'orange', 'yellow', 'green', 'blue', 'violet'] obj1.pensize(3) for i, color in enumerate(colors): square(obj1, (panel_y / 2) / 10 * (i+1), color) print('Hit any key to exit') dummy = input()
Main Program Call
if __name__ == '__main__':
For Loop Example#2
Program to concatenate two LISTS into a dictionary.
Count to be processed
var1=int(input("Count of elements for the dictionry:"))
print (Key Elements)
for x in range(0,var1): element=int(input("Element item entered" + str(x+1) + ":")) Key_elements.append(element)
Print (Value Elements)
for x in range(0,var1): element=int(input("Element item entered" + str(x+1) + ":")) value_elements.append(element) d=dict(zip(Key_elements,value_elements)) #Print Section print("The formulated dictionary is:") print(d)
Nested looping is the process of looping one loop within the boundaries of others. So when the control flows from the outer loop to the inner loop, it returns back to the outer loop only when the inner loops are completed. Indentation is used to determine the body of the nested loops. Indentation starts the loop, and the line from which it starts to be unindented represents the end of the mentioned loop.
for iterating_variable#1 in sequence#1:
for iterating_variable#2 in sequence#2:
Nested Loop Example
Python Program for File Handling
import os def listfile(types): current_path,filename = os.path.split(os.path.abspath(__file__))
Nested Looping Section in The Program
Outer For Loop - - - - - - - - - -# for path,dir,file in os.walk(current_path): file_name = str(file)
Inner For Loop
for type in types: if file_name.endswith(type): print(file_name) def deletefile(types): choice2 = input("Please enter the file to delete : ") os.remove(choice2) types = [".txt']",".srt]",".py]"]
print(" = = = = = = = = = = = = = = = = = = = = = " ) print(" $$$$$$$$$$$$$ FILE HANDELING $$$$$$$$$$$$ ") print(" = = = = = = = = = = = = = = = = = = = = = ")
File_list = listfile(types)
Print( Bye Bye )
Print( Invalid Option )
Python Loop Control Statements
Loops iterate above a block of code pending expression in testis false, but when there is an instance where we need to stop the loop without a check to the condition, that is where the loop control statements come into play. The three major loop control statements in python are as below:
- Break: Terminates the loop and passes the control to the statement after the loop. If a break is mentioned into a nested loop, then it is the innermost loop is where the break will initially terminate.
- Continue: Skips the remaining sentences in the loop and checks the condition posted in the loop.
- Pass: It just passes the execution when reaching a specific statement.
Loop Control Statements example
Python Program Using Loop Control Statements
var_a = 1 var_b = 2 while var_a < var_b: print(" Code enters while loop ") var_c = ["SUV","sedan","hatchback","End"] for iterator in var_c: if iterator == "SUV": print("Hyundai creata") print("Mahindra bolero") print("---------------") if iterator == "sedan":
Loop Control Statement: Pass
pass if iterator =="hatchback": print("Renault Kwid") print("suzuki alto") print("---------------") if iterator == "End":
Loop Control Statement: Break
var_a = var_a+1
Benefits of python Loops: The key advantages of loops are as below:
- Code reduction.
- Reduces code complexity.
- Brings in more stability into coding.
- Code redundancy is greatly resolved.
Conclusion – Loops in Python
The dominance exhibited by any programming language depends on the classified set of coding functionalities. In such instances, python programming’s looping structure is largely stable and flexible to code which stands out to be among the prior reasons which make this language dominate the market.
This has been a guide to Loops in Python. Here we discuss what the Loops in Python are, While loops, and much more with appropriate sample code. You can also go through our other suggested articles to learn more –