Python Programming

Python is a high-level programming language — a language written in words close to English, which the computer translates into machine instructions for you. Everything in this chapter follows Python 3. If you meet older code that writes print "Hello" without brackets, that is Python 2 and it will not run in Python 3, so do not copy that style into your answer sheet.

A variable is a named location in memory that stores a value. You create one simply by assigning to it with the assignment operator =. There is no separate declaration line in Python: the moment you assign, the variable exists and its type is decided by the value you gave it.

name = "Ananya"
roll = 21
fee = 1250.50
passed = True

The name of a variable is called an identifier, and the rules for a valid identifier are asked for in exactly this form. An identifier may contain letters, digits and the underscore. It must not begin with a digit. It must not contain a space or a special symbol such as @, - or #. It must not be a keyword — a word already reserved by Python, such as if, else, for, while, True or break. Finally, identifiers are case sensitive, so Marks, marks and MARKS are three different variables. A name such as total_fee is valid; total fee, 2ndterm and class are not.

The data type of a value tells Python what kind of data it is and what may be done with it. Four types cover almost every question at this level, and a fifth (the list) has a section of its own.

• int — a whole number, positive, negative or zero: 21, -7, 0.
• float — a number with a decimal point: 1250.50, 3.0.
• str — a string, that is text in quotes: "Ananya", '10'.
• bool — a Boolean value, only True or False, written with a capital letter.

The built-in function type() reports the type: print(type(fee)) shows that fee is a float. Python is dynamically typed, which means the type follows the value — assigning roll = "twenty one" later would make roll a string.

Output is produced by print(). When you pass several items separated by commas, Python prints them in order with a single space between them, then moves to a new line.

Input is read by input(), and here is the point examiners test most: input() always returns a string, even when the user types digits. To calculate with it you must convert, using int() for whole numbers or float() for decimals. Forgetting the conversion is why 2 and 3 sometimes join into "23" instead of adding to 5.

price = int(input("Enter price in rupees: "))
qty = int(input("Enter quantity: "))
print("Total payable =", price * qty)

The arithmetic operators are +, -, *, /, //, % and **. Two of them are examined constantly: / is true division and always gives a float, so 17 / 5 is 3.4, while // is floor division and gives the whole part, so 17 // 5 is 3. The remainder operator % gives 17 % 5 as 2, and it is the standard way to test divisibility: a number n is even when n % 2 == 0. Exponentiation ** gives 2 ** 3 as 8.

Anything after a # on a line is a comment; Python ignores it. Comments do not earn marks by themselves, but one line explaining a tricky step reads well and costs nothing.

A program that always does the same thing is of little use. Decision making lets a program test a condition — an expression that evaluates to True or False — and run one block of statements or another.

Conditions are built from the relational operators: == (equal to), != (not equal to), >, <, >= and <=. Two or more conditions are combined with the logical operators and (true only when both sides are true), or (true when at least one side is true) and not (reverses a condition). Note the double equals sign in ==. A single = is assignment, not comparison, and putting it in a condition is an error you will meet again at the end of this chapter.

The simplest form is if alone:

marks = int(input("Enter marks: "))
if marks >= 33:
    print("Pass")

Two details in those three lines are syntax, not style. First, the if header ends with a colon. Second, the statements controlled by the if are indented — pushed in from the left margin. Most other languages mark a block with braces and treat indentation as a courtesy to the reader; Python has no braces, so the indentation itself defines the block. Miss the colon and Python reports a SyntaxError; indent wrongly and it reports an IndentationError.

The accepted convention is four spaces for each level, and every line of one block must be indented by the same amount. Do not mix tabs and spaces: editors differ in how wide they draw a tab — some show four columns, others eight — so code that looks aligned on one machine can be rejected on another. Set your editor to insert spaces when you press Tab, or simply press the space bar four times.

Adding else supplies the alternative path. The else keyword takes no condition, and it is written at the same indentation as its if:

n = int(input("Enter a number: "))
if n % 2 == 0:
    print(n, "is even")
else:
    print(n, "is odd")

When there are more than two paths, use elif — short for else if. You may write as many elif branches as you need, and a final else is optional. Python tests the conditions from the top downwards, stops at the first one that is true, runs that block and skips every remaining branch. That single sentence is what a full-mark answer on elif contains.

marks = int(input("Enter marks out of 100: "))

if marks >= 90:
    print("Grade A")
elif marks >= 75:
    print("Grade B")
elif marks >= 60:
    print("Grade C")
elif marks >= 33:
    print("Grade D")
else:
    print("Needs improvement")

Because the first true branch wins, the order of the tests matters. If you had written marks >= 33 first, then 95 marks would satisfy it and print "Grade D", and no later branch would ever run. When the boundaries overlap like this, arrange them from the strictest to the loosest.

The classic examination program for this topic is the largest of three numbers, and it can be answered with a single ladder:

a = int(input("Enter first number: "))
b = int(input("Enter second number: "))
c = int(input("Enter third number: "))

if a >= b and a >= c:
    print("Largest =", a)
elif b >= a and b >= c:
    print("Largest =", b)
else:
    print("Largest =", c)

Using >= rather than > matters: if all three numbers are equal, > would fall through every branch to the else and still be right by luck, but with two equal largest values a strict > test can miss. Write >= and the answer is safe in every case.

An if may also be placed inside another if; this is a nested if, and the inner block is simply indented one level further. Prefer an elif ladder where you can — it is shorter and much easier to mark.

A loop repeats a block of statements. The while loop repeats it as long as a condition remains true, and it is the right choice when you do not know in advance how many repetitions are needed.

Every correct while loop has three moving parts, and naming them earns marks in a theory question:

1. Initialisation — the control variable is given a starting value before the loop.
2. Test — the condition in the while header, checked before every repetition.
3. Update — a statement inside the body that moves the control variable towards making the condition false.

i = 1                 # initialisation
while i <= 5:         # test
    print(i, end=" ")
    i = i + 1         # update
print()

The output is 1 2 3 4 5. The end=" " argument tells print to finish with a space instead of a new line, so the numbers appear on one line; the bare print() afterwards moves to the next line.

Because the condition is tested before the body runs, while is called an entry-controlled loop, and the body may run zero times. If i started at 9 in the loop above, nothing at all would be printed. Examiners like this point, so state it plainly.

Remove the update line and i stays 1 for ever, the condition stays true, and you have an infinite loop. In most environments pressing Ctrl+C interrupts a runaway program, but the real cure is to check, before you write the closing line of the body, that something inside it changes the variable the condition depends on.

Two patterns cover nearly every while question in the paper. The first is the accumulator: a variable set to a starting value outside the loop, then built up inside it. For a sum the accumulator starts at 0, because adding 0 changes nothing.

n = int(input("Enter n: "))
total = 0
i = 1
while i <= n:
    total = total + i
    i = i + 1
print("Sum of first", n, "natural numbers =", total)

For a product the accumulator starts at 1, because multiplying by 1 changes nothing — starting it at 0 would make every answer 0, a very common slip.

n = int(input("Enter a number: "))
fact = 1
i = 1
while i <= n:
    fact = fact * i
    i = i + 1
print("Factorial of", n, "is", fact)

Trace it for n = 4, which is exactly what a dry-run question asks you to write out:

• Before the loop: fact = 1, i = 1.
• Pass 1: 1 <= 4 is true, fact = 1 * 1 = 1, i becomes 2.
• Pass 2: fact = 1 * 2 = 2, i becomes 3.
• Pass 3: fact = 2 * 3 = 6, i becomes 4.
• Pass 4: fact = 6 * 4 = 24, i becomes 5.
• Test: 5 <= 4 is false, the loop ends, and 24 is printed.

Notice that for n = 0 the body never runs and the answer printed is 1, which is the correct value of 0 factorial.

The second pattern is the sentinel-controlled loop, where the user keeps entering values until a chosen stopping value is typed. Here the number of repetitions is genuinely unknown, so while is the natural choice.

total = 0
value = int(input("Enter an amount in rupees (0 to stop): "))
while value != 0:
    total = total + value
    value = int(input("Enter an amount in rupees (0 to stop): "))
print("Total =", total)

The input statement appears twice on purpose: once before the loop so the first test has something to examine, and once at the end of the body so the next test has a fresh value. That repeated line is the update.

The for loop repeats its body once for each item of a sequence. The sequence can be a range of numbers, a list or a string, and the loop variable takes each item in turn. Use for when the number of repetitions is known or countable; use while when it is not.

The sequence of numbers usually comes from the built-in function range(), which has three forms.

• range(stop) — counts from 0 up to but not including stop. range(5) gives 0, 1, 2, 3, 4.
• range(start, stop) — counts from start up to but not including stop. range(2, 6) gives 2, 3, 4, 5.
• range(start, stop, step) — counts from start, adding step each time, stopping before stop. range(1, 10, 2) gives 1, 3, 5, 7, 9.

Learn one sentence and half the output questions in this chapter answer themselves: the stop value is always excluded, and the start value is always included. So range(1, 5) produces four numbers, not five, and the count of values in range(a, b) is b - a.

The step may be negative, which counts downwards. range(5, 0, -1) gives 5, 4, 3, 2, 1 — again the stop value 0 is left out. range(10, 0, -2) gives 10, 8, 6, 4, 2. If the start has already passed the stop in the direction of travel, the range is empty and the loop body never runs at all: range(5, 1) produces nothing, because the default step of +1 can never reach downwards.

The multiplication table is the standard for question:

n = int(input("Enter a number: "))
for i in range(1, 11):
    print(n, "x", i, "=", n * i)

The 11 is deliberate. To run from 1 to 10 inclusive you must write range(1, 11); writing range(1, 10) stops at 9 and leaves the last row out. Whenever a question says "from 1 to n", the correct range is range(1, n + 1).

Two keywords change the normal flow. break leaves the loop immediately, skipping the remaining items altogether. continue skips the rest of the current pass only and jumps straight to the next item.

for i in range(1, 11):
    if i == 5:
        break
    print(i, end=" ")

That prints 1 2 3 4 and then stops for good. Replace break with continue and the output becomes 1 2 3 4 6 7 8 9 10 — only the value 5 is missed, and the loop carries on. A neat use of continue is printing the odd numbers:

for i in range(1, 11):
    if i % 2 == 0:
        continue
    print(i, end=" ")

which prints 1 3 5 7 9.

A loop written inside the body of another loop is a nested loop. The rule to state in an answer is that the inner loop completes all its repetitions for every single pass of the outer loop. If the outer loop runs 3 times and the inner loop runs 4 times, the innermost statement runs 3 × 4 = 12 times.

for i in range(1, 4):
    for j in range(1, 4):
        print(i * j, end=" ")
    print()

The output has three lines: 1 2 3, then 2 4 6, then 3 6 9. Notice where the bare print() sits — indented to the outer loop, not the inner one — so it runs once per row and ends the line.

Pattern printing uses the same idea with the inner range depending on the outer variable:

for i in range(1, 5):
    for j in range(1, i + 1):
        print("*", end="")
    print()

This prints one star, then two, then three, then four, on four lines. One last caution: a break written inside the inner loop leaves only the inner loop; the outer loop continues with its next value.

A list is an ordered collection of values stored under one name. It is written inside square brackets with the items separated by commas, and it may hold items of different types, though in exam questions it usually holds numbers or strings.

marks = [78, 85, 62, 91, 55]
names = ["Ananya", "Rahul", "Meera"]
empty = []

Each item has a position number called its index. Indexing starts at 0, so the valid indices of a list of five items are 0, 1, 2, 3 and 4 — the last index is always len - 1. Python also supports negative indexing, which counts from the right: -1 is the last item, -2 the second last, and so on. This is why marks[-1] is the neat way to reach the last item without knowing the length.

marks = [78, 85, 62, 91, 55]
print(marks[0])    # 78
print(marks[3])    # 91
print(marks[-1])   # 55
print(marks[-2])   # 91
print(len(marks))  # 5

Asking for an index that does not exist, such as marks[5] here, raises an IndexError. The function len() returns the number of items, and it is the safe way to find the last index: marks[len(marks) - 1].

A slice takes a part of the list and gives back a new list. The form is list[start:stop], and — exactly as with range() — the stop position is excluded. Omitting start means "from the beginning"; omitting stop means "to the end".

marks = [78, 85, 62, 91, 55]
print(marks[1:4])   # [85, 62, 91]
print(marks[:3])    # [78, 85, 62]
print(marks[2:])    # [62, 91, 55]
print(marks[-2:])   # [91, 55]

Unlike a string, a list is mutable — it can be changed in place. marks[0] = 90 replaces the first item, and the methods below change the list itself rather than returning a changed copy.

• append(item) — adds one item at the end.
• insert(pos, item) — inserts the item at position pos, shifting the rest to the right.
• remove(value) — deletes the first occurrence of that value; raises a ValueError if the value is not present.
• pop() — removes and returns the last item; pop(index) removes and returns the item at that index.
• sort() — rearranges the list into ascending order in place; sort(reverse=True) gives descending order.
• reverse() — reverses the order of the items in place.

fees = [1200, 1500, 900]
fees.append(2000)      # [1200, 1500, 900, 2000]
fees.insert(1, 1000)   # [1200, 1000, 1500, 900, 2000]
fees.remove(900)       # [1200, 1000, 1500, 2000]
x = fees.pop()         # x = 2000, fees = [1200, 1000, 1500]
y = fees.pop(0)        # y = 1200, fees = [1000, 1500]
fees.sort()            # [1000, 1500]
fees.reverse()         # [1500, 1000]

Three distinctions are worth memorising. First, remove() takes a value while pop() takes a position. Second, append() adds a single item: starting from nums = [1, 2, 3], the call nums.append([4, 5]) puts the whole small list in as one item, giving [1, 2, 3, [4, 5]]. Third, sort() and reverse() return None, so writing marks = marks.sort() throws the list away and leaves marks holding None. Call marks.sort() on its own line.

Traversal means visiting every item. The direct form loops over the list itself; the indexed form is used when you also need the position.

marks = [78, 85, 62, 91, 55]

for m in marks:
    print(m, end=" ")
print()

for i in range(len(marks)):
    print("Index", i, "holds", marks[i])

The standard traversal question is finding the largest value. Set the answer to the first item, then improve it as you walk through the rest:

marks = [78, 85, 62, 91, 55]
largest = marks[0]
for m in marks:
    if m > largest:
        largest = m
print("Largest =", largest)

Start largest at marks[0], never at 0 — a list of negative values would then report 0, which is not even in the list. The same shape with < finds the smallest, and adding total = total + m finds the sum.

A string is a sequence of characters enclosed in quotes. Single and double quotes are both accepted and mean the same thing; choose the pair that the text itself does not contain, so "Ananya's marks" is easiest with double quotes.

Because a string is a sequence, everything you learned about list positions applies. Indexing starts at 0, the last character is at index len - 1, and negative indices count from the right with -1 as the last character. The space is a character too and occupies its own index.

s = "Computer"
print(len(s))    # 8
print(s[0])      # C
print(s[3])      # p
print(s[-1])     # r
print(s[2:5])    # mpu
print(s[:4])     # Comp
print(s[4:])     # uter

Slicing follows the same exclusive-stop rule: s[2:5] gives the characters at indices 2, 3 and 4. The slice s[::-1] uses a step of −1 and therefore produces the whole string backwards, which is the shortest way to reverse a string.

The one big difference from a list is that a string is immutable — once created it cannot be changed. Writing s[0] = "R" raises a TypeError. To "change" a string you build a new one and assign it back, and that is why string methods hand you a fresh string rather than editing the original.

Two operators are examined by name. Concatenation with + joins two strings end to end. Both operands must be strings — "Roll " + 21 is a TypeError, and you must write "Roll " + str(21). Repetition with * repeats a string a whole number of times, so "ab" * 3 is "ababab"; here one operand must be a string and the other an integer.

first = "Priya"
last = "Sharma"
full = first + " " + last
print(full)          # Priya Sharma
print("-" * 20)      # a line of 20 hyphens
print(len(full))     # 12

Note the deliberate " " in the middle: + adds no space of its own, unlike the comma in print.

Two methods are on the syllabus. upper() returns a copy in capitals and lower() returns a copy in small letters. Both return a new string and leave the original untouched, so s.upper() on its own line accomplishes nothing — you must use the returned value or assign it.

city = "delhi"
print(city.upper())   # DELHI
print(city)           # delhi  (unchanged)
city = city.upper()
print(city)           # DELHI

Traversal visits each character. The direct form gives you the characters; the indexed form gives you positions as well.

s = "India"
for ch in s:
    print(ch, end=" ")
print()

for i in range(len(s)):
    print(i, s[i])

The operator in tests whether one string occurs inside another, which makes the vowel-counting program short. Converting each character with lower() means capital vowels are counted too.

s = input("Enter a string: ")
count = 0
for ch in s:
    if ch.lower() in "aeiou":
        count = count + 1
print("Number of vowels =", count)

Reversing a string can be done in one line with a slice, or with the loop the examiner may ask for. In the loop version each new character is placed in front of what has been built so far:

s = input("Enter a string: ")
rev = ""
for ch in s:
    rev = ch + rev
print("Reversed:", rev)

Trace it on "cat": rev becomes "c", then "ac", then "tac". Writing rev = rev + ch instead would simply rebuild the original string.

A palindrome is a word that reads the same forwards and backwards, such as level, nitin or malayalam. Converting to one case first makes the test fair for words typed with a capital letter.

s = input("Enter a word: ").lower()
if s == s[::-1]:
    print("Palindrome")
else:
    print("Not a palindrome")

Programming questions are marked on more than the output. A full-mark answer generally contains four things: an input step with a clear prompt and the right conversion, a processing step using the correct loop or condition, an output step that prints a labelled result rather than a bare number, and correct indentation throughout. Sensible variable names such as total and largest make the logic obvious to whoever reads your paper.

Almost every program on this syllabus is one of three shapes. The accumulator shape sets a variable outside the loop and builds it up inside — sum of n numbers (start at 0) and factorial (start at 1). The running best shape sets the answer to the first candidate and improves it — largest of three, largest in a list. The build a new sequence shape starts with an empty string or list and adds to it — reversing a string, counting vowels. Recognise the shape and the code writes itself.

Error 1: the off-by-one range. Because the stop value of range() is excluded, a loop meant to run from 1 to n must be written range(1, n + 1). Writing range(1, n) silently drops the last value, so a table of 7 stops at 7 × 9 and a factorial of 5 comes out as 24. The mirror image happens with indices: range(len(marks)) gives 0 up to len - 1, which is exactly the set of valid indices, whereas range(1, len(marks)) skips item 0 and range(len(marks) + 1) runs one step too far and raises an IndexError. Before you hand in a loop, check the very first and the very last value it produces; those are the only two places this error hides.

Error 2: modifying a list while iterating over it. A for loop walks a list by position. If you delete items during the walk, the remaining items shift left while the position counter keeps moving right, so some items are stepped over entirely.

nums = [1, 2, 2, 3, 2, 4]
for n in nums:
    if n == 2:
        nums.remove(n)
print(nums)      # [1, 3, 2, 4]  -- one 2 survives

The loop looks correct and even runs without an error message, which is what makes it dangerous. The fix is to leave the list you are walking alone. Either iterate over a copy, using the full slice nums[:], or build a new list of the items you wish to keep:

nums = [1, 2, 2, 3, 2, 4]
for n in nums[:]:
    if n == 2:
        nums.remove(n)
print(nums)      # [1, 3, 4]

nums = [1, 2, 2, 3, 2, 4]
keep = []
for n in nums:
    if n != 2:
        keep.append(n)
print(keep)      # [1, 3, 4]

Error 3: confusing = with ==. The single = is the assignment operator: it stores a value in a variable. The double == is the equality operator: it compares two values and produces True or False. Writing if n = 5: is a SyntaxError in Python, and the program will not run at all — which is at least a loud failure. The quiet failure is the opposite slip inside a loop:

total == total + i    # compares, then throws the result away
total = total + i     # correct: stores the new total

The first line is legal Python, produces no error, and leaves total unchanged for ever, so the program prints a wrong answer with complete confidence. Read every line inside a loop and ask whether it is meant to store or to test.

Three smaller mistakes are worth a final look. Forgetting the colon after an if, while or for header gives a SyntaxError. Indenting inconsistently — four spaces on one line and three on the next — gives an IndentationError. And comparing raw input to a number never works: input() returns the string "10", and "10" == 10 is False, so the condition if input("Enter: ") == 10: can never be true. Convert first with int().

Finally, practise the dry run. Draw a small table with one column per variable, write the value after each pass of the loop, and stop when the condition fails. Two minutes of dry running catches off-by-one errors and wrong starting values far more reliably than reading the code again.