Indentation

• Python uses indentation (whitespace) to define code blocks instead of curly braces.
• Indentation is part of the syntax, not just for readability.
• All statements in the same block must have the same indentation level.
• After a colon :, the next line must be indented.
• Standard indentation is 4 spaces per level (tabs are discouraged).

1
if x > 5:
2
    print("x is greater than 5")  # Indented
3
    print("This is also inside")  # Same indentation
4
print("This is outside")          # Not indented

Semicolons

• Semicolons separate statements on the same line, they don’t terminate them.
• Cannot separate a simple statement from a compound statement (like a loop).
• Generally discouraged as it goes against Python’s readability philosophy.

1
x = 1; y = 2  # Valid: two simple statements
2
if x > 0: print(x); print(y)  # Valid: simple statements in suite
3
print("Hello"); for i in range(5): print(i)  # ERROR: cannot separate simple from compound

Simple vs Compound Statements

• Simple statement: Executes as one unit (e.g., x = 5, print(x), break).
• Compound statement: Contains other statements and controls a suite (e.g., if, while, for).
• A suite can be either:
  • Indented block on new lines
  • Semicolon-separated simple statements on the same line

Basic Syntax

1
while condition:
2
    # loop body here

• The condition is checked before each iteration.
• Loop continues as long as the condition is True.
• Must ensure the condition becomes False to avoid infinite loops.

1
i = 0
2
while i < 5:
3
    print(i)
4
    i += 1

Flags

• A flag is a boolean variable that acts as an indicator or signal.
• Used to control loop execution or track state.

1
running = True
2
total = 0
3
while running:
4
    num = int(input("Enter a number: "))
5
    if num < 0:
6
        running = False
7
    else:
8
        total += num

Infinite Loops

• A loop that runs forever (or without a bound).
• Sometimes intentional: while True: with break inside.
• Often a bug when the condition never becomes False.

1
while True:
2
    password = input("Enter password: ")
3
    if password == "correct":
4
        break

Nested Loops

• A loop inside another loop.
• Inner loop completes fully for each iteration of the outer loop.

1
for i in range(2):
2
    for j in range(3):
3
        print("i=", i, ", j=", j, end="; ")
4
# Output: i=0, j=0; i=0, j=1; i=0, j=2; i=1, j=0; i=1, j=1; i=1, j=2;

continue

• Skips the remainder of the current iteration and moves to the next one.
• Only affects the innermost loop when nested.

1
for i in range(10):
2
    if i % 2 != 0:
3
        continue
4
    print(i)

break

• Terminates the current loop immediately.
• Only breaks out of the innermost loop when nested.

1
while True:
2
    num = int(input("Enter a number: "))
3
    if num < 0:
4
        break
5
    print(num)

else with Loops

• The else clause executes only if the loop completes normally (without a break).

1
for i in range(2, n):
2
    if n % i == 0:
3
        print("Not prime")
4
        break
5
else:
6
    print("Prime")

range(n) - One Argument

• Generates numbers from 0 up to (but not including) n.
• Produces n numbers: 0, 1, 2, ..., n-1.

1
list(range(5))  # [0, 1, 2, 3, 4]

range(start, end) - Two Arguments

• Generates numbers from start (inclusive) up to (but not including) end.

1
list(range(2, 8))  # [2, 3, 4, 5, 6, 7]

range(start, end, step) - Three Arguments

• Generates numbers starting from start, up to (but not including) end, incrementing by step.

1
list(range(0, 10, 2))  # [0, 2, 4, 6, 8]
2
list(range(1, 10, 2))  # [1, 3, 5, 7, 9]

Negative Step

• When step is negative, the range counts backwards.
• Start must be greater than end for the range to produce values.

1
list(range(10, 0, -1))  # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
2
list(range(20, 0, -2))  # [20, 18, 16, 14, 12, 10, 8, 6, 4, 2]

len()

• Returns the number of items in an object.

1
len("Hello")        # 5
2
len(range(5))       # 5
3
len(range(2, 10))   # 8

min() and max()

• min() returns the smallest item; max() returns the largest.
• With strings, compares based on Unicode values.

1
min("Hello")        # 'H'
2
max("Hello")        # 'o'
3
min(range(5, 15))   # 5
4
max(range(5, 15))   # 14

sum()

• Adds all numbers in an iterable and returns the total.

1
sum(range(1, 6))        # 15
2
sum(range(0, 11, 2))    # 30

abs()

• Returns the absolute value of a number.

1
abs(5)      # 5
2
abs(-5)     # 5
3
abs(0)      # 0

pow()

• pow(x, y) returns x raised to the power of y.
• pow(x, y, z) returns (x ** y) % z (modular exponentiation).

1
pow(2, 3)       # 8
2
pow(2, 3, 5)    # 3

round()

• Rounds a number to the nearest integer or specified decimal places.

1
round(3.7)          # 4
2
round(3.14159, 2)   # 3.14

chr() and ord()

• ord(char) returns the Unicode code point of a character.
• chr(code) returns the character for a Unicode code point.

1
ord('A')    # 65
2
chr(65)     # 'A'

id()

• Returns the unique identifier (memory address) of an object.
• Useful for understanding if two variables refer to the same object.

Sequences

• Sequence: An ordered collection of items with specific positions (indices).
• Types: strings, lists, tuples, range objects, bytes, bytearrays, buffers.
• Characteristics:
  • Ordered: Items have specific positions (index starting from 0)
  • Indexable: Access items by position using [index]
  • Sliceable: Extract portions using slicing [start:end]
  • Length: Get number of items using len()
  • Iterable: Can be processed item by item

Iterables

• Iterable: Any object that can produce items one at a time.
• All sequences are iterables, but not all iterables are sequences.
• Examples: sequences, sets, dictionaries, files, generators.

Common Sequence Operations

1
text = "Python"
2
text[0]     # 'P'
3
text[-1]    # 'n'
4
text[-2]    # 'o'

1
text = "Python"
2
text[0:3]   # "Pyt"
3
text[2:]    # "thon"
4
text[:4]    # "Pyth"
5
text[::2]   # "Pto"
6
text[::-1]  # "nohtyP"

1
"P" in "Python"     # True
2
"x" not in "Python" # True

1
"Hello" + " " + "World"  # "Hello World"
2
"Hi" * 3                 # "HiHiHi"

Basic Syntax

1
for variable in sequence:
2
    # loop body here

• The variable takes each value from the sequence one at a time.
• Automatically handles iteration—no need to manually increment or check conditions.

1
for i in range(5):
2
    print(i)  # Prints 0, 1, 2, 3, 4

Using range() with for loops

1
for i in range(5):           # 0, 1, 2, 3, 4
2
for i in range(2, 8):        # 2, 3, 4, 5, 6, 7
3
for i in range(1, 10, 2):    # 1, 3, 5, 7, 9
4
for i in range(20, 0, -2):   # 20, 18, 16, 14, 12, 10, 8, 6, 4, 2

For Loops vs While Loops

Use for loops when:

• The number of iterations is known in advance.
• Iterating over a sequence.
• You want simpler, more readable code.

Use while loops when:

• The number of iterations is unknown.
• Complex condition logic is needed.
• Repeating until an event occurs.

Control Flow with for loops

• continue: Skip to next iteration.
• break: Exit the loop.
• else: Execute if loop completes normally (no break).

1
for i in range(10):
2
    if i % 2 != 0:
3
        continue  # Skip odd numbers
4
    print(i)      # Print even numbers

Nested for loops

1
for i in range(3):
2
    for j in range(3):
3
        print("i=", i, "j=", j)

dir()

• Returns a list of names (attributes and methods) available in an object.
• Called without arguments: shows names in current scope.
• Called with an object: shows attributes and methods of that object.

1
dir()              # Names in current scope
2
dir("hello")       # Methods available for strings

help()

• Displays documentation (docstrings) for objects, functions, modules, or keywords.
• Shows how to use something, while dir() shows what’s available.

1
help(print)            # Documentation for print function
2
help("hello".upper)    # Documentation for upper method

• Use dir() to discover what’s available, then help() to learn how to use it.