Introduction to Python Programming

Introduction: The Power of Automation

Imagine you have a list of a hundred student names and you need to print a personalized welcome message for each. Or perhaps you need to process every line in a large text file. Manually writing `print()` statements or copying-pasting code a hundred times would be incredibly tedious, error-prone, and inefficient. This is where loops become your best friend.

Loops are fundamental programming constructs that allow you to execute a block of code repeatedly. They are the engine of automation in your programs, enabling you to process collections of data, perform actions until a condition is met, and avoid redundant code.

At UdaanPath, we emphasize writing efficient and elegant code. Mastering loops is a critical step towards this goal, letting your programs do the repetitive grunt work so you don't have to.

Core Concepts: Looping Through Your Logic

for variable in iterable:
    # Code block to execute for each item
    # (This block MUST be indented)
                    

word = "UdaanPath"

print("Letters in 'UdaanPath':")
for char in word:
    print(char)
                    

Letters in 'UdaanPath':
U
d
a
a
n
P
a
t
h

print("Counting to 5:")
for i in range(5): # 0, 1, 2, 3, 4
    print(i + 1) # Print 1 to 5

print("\nNumbers from 5 to 9:")
for num in range(5, 10): # 5, 6, 7, 8, 9
    print(num)

print("\nEven numbers from 0 to 10:")
for x in range(0, 11, 2): # 0, 2, 4, 6, 8, 10
    print(x)
                    

Counting to 5:
1
2
3
4
5

Numbers from 5 to 9:
5
6
7
8
9

Even numbers from 0 to 10:
0
2
4
6
8
10

while condition:
    # Code block to execute as long as condition is True
    # (MUST be indented)
    # Important: Make sure the condition eventually becomes False
                    

count = 0
print("Counting with while loop:")
while count < 3:
    print(f"Count is: {count}")
    count += 1 # Increment count, so it eventually becomes 3
print("Loop finished.")
                    

Counting with while loop:
Count is: 0
Count is: 1
Count is: 2
Loop finished.

correct_password = "UdaanPass123"
user_tries = 0

print("Please enter the secret UdaanPath password.")
while user_tries < 3:
    entered_password = input("Password: ")
    if entered_password == correct_password:
        print("Access granted! Welcome, UdaanPath Learner.")
        break # Exit the loop immediately upon success
    else:
        user_tries += 1
        print(f"Incorrect password. You have {3 - user_tries} tries left.")

if user_tries == 3 and entered_password != correct_password:
    print("Too many incorrect attempts. Access denied.")
                    

Please enter the secret UdaanPath password.
Password: wrong
Incorrect password. You have 2 tries left.
Password: again
Incorrect password. You have 1 tries left.
Password: fail
Incorrect password. You have 0 tries left.
Too many incorrect attempts. Access denied.
Password: UdaanPass123
Access granted! Welcome, UdaanPath Learner.

fruits = ["apple", "banana", "cherry", "orange", "grape"]
search_fruit = "cherry"

print(f"Searching for '{search_fruit}':")
for fruit in fruits:
    if fruit == search_fruit:
        print(f"Found {search_fruit}!")
        break # Exit the loop once found
    print(f"Still looking... current fruit: {fruit}")
print("Search complete.")
                    

Searching for 'cherry':
Still looking... current fruit: apple
Still looking... current fruit: banana
Found cherry!
Search complete.

print("Printing only odd numbers from 1 to 5:")
for number in range(1, 6): # numbers 1, 2, 3, 4, 5
    if number % 2 == 0: # If number is even
        continue # Skip the print statement for even numbers
    print(f"Odd number: {number}")
                    

Printing only odd numbers from 1 to 5:
Odd number: 1
Odd number: 3
Odd number: 5

print("UdaanPath Multiplication Table (1-3):")
for i in range(1, 4): # Outer loop for rows (1, 2, 3)
    for j in range(1, 4): # Inner loop for columns (1, 2, 3)
        product = i * j
        print(f"{i} * {j} = {product}\t", end="") # \t for tab, end="" to stay on same line
    print() # Newline after each row (outer loop iteration)
                    

UdaanPath Multiplication Table (1-3):
1 * 1 = 1	1 * 2 = 2	1 * 3 = 3	
2 * 1 = 2	2 * 2 = 4	2 * 3 = 6	
3 * 1 = 3	3 * 2 = 6	3 * 3 = 9	

Key Takeaways & Best Practices

• Choose the Right Loop: Use `for` when you know how many times you need to iterate (e.g., over items in a list, or a fixed range of numbers). Use `while` when the number of iterations is unknown and depends on a condition becoming false (e.g., user input validation, reading until end of file).
• Prevent Infinite `while` Loops: Always ensure that the condition controlling a `while` loop will eventually become `False` to prevent your program from freezing.
• Indentation is Crucial: Like `if` statements, loop bodies are defined by indentation. Consistent 4-space indentation is standard.
• Use `break` and `continue` Judiciously: These statements provide powerful flow control but can sometimes make loops harder to read if overused. Aim for clear logic first.
• Understand Nested Loop Behavior: The inner loop completes all its iterations for every single iteration of the outer loop. This can lead to a large number of total operations if not managed carefully.
• Iterate Directly Over Items: In Python, it's often more "Pythonic" to loop directly over the items of a sequence (`for item in list:`) rather than using an index (`for i in range(len(list)):`), unless you specifically need the index.

Interview Tip: Expect questions on the difference between `for` and `while` loops, when to use `break` vs. `continue`, and how to prevent infinite loops. Writing nested loops for patterns or tabular data is a common coding challenge.

Mini-Challenge: UdaanPath Word Analyzer!

Let's combine your new loop skills with your previous string knowledge! Create a Python script named `word_analyzer.py` that analyzes a user-entered word.

• Ask the user to `input()` a word.
• Using a for loop, iterate through each character of the word.
• Inside the loop, count the number of vowels (a, e, i, o, u, case-insensitive) in the word.
• Using a while loop, repeatedly ask the user to guess a letter in the word until they guess correctly, or they run out of 3 tries.
  • If the guess is correct, print "Correct guess!" and `break` the loop.
  • If incorrect, print "Wrong letter. Try again!" and decrement tries.
  • If 3 tries are exhausted, print "You're out of tries!"
• Finally, print the total vowel count and a message summarizing the letter guessing game.

Run your `word_analyzer.py` script and see your loops in action!

# word = input("Enter a word for UdaanPath analysis: ").lower() # Convert to lowercase for easier vowel check

# vowel_count = 0
# for char in word:
#     # Your vowel counting logic here using 'if' and 'in' operator for strings
#     pass # Replace pass

# print(f"The word '{word}' has {vowel_count} vowels.")

# max_tries = 3
# guess_count = 0
# guessed_correctly = False

# while guess_count < max_tries:
#     # Your guessing game logic here
#     pass # Replace pass

# if guessed_correctly:
#     print("Great job guessing the letter!")
# else:
#     print("Better luck next time with the letter guessing.")
                

$ python word_analyzer.py
Enter a word for UdaanPath analysis: Programming
The word 'programming' has 4 vowels.
Guess a letter in the word: p
Correct guess!
Great job guessing the letter!

$ python word_analyzer.py
Enter a word for UdaanPath analysis: Python
The word 'python' has 1 vowels.
Guess a letter in the word: z
Wrong letter. You have 2 tries left.
Guess a letter in the word: x
Wrong letter. You have 1 tries left.
Guess a letter in the word: k
Wrong letter. You have 0 tries left.
You're out of tries!
Better luck next time with the letter guessing.