Python Basics

Python Basics | Algoryva

Intuition

A program is a recipe

A recipe is a list of steps a cook follows exactly, with no common sense: “if the sauce is thick, add water; repeat until smooth”. A program is the same: a list of steps, followed literally by a computer that is very fast and has no judgement at all.

Three ideas cover almost everything: remember things (variables), decide between steps (conditions), and repeat steps (loops). Functions let you give a group of steps a name so you can reuse it.

First, the naive way

Doing each calculation by hand

Suppose you need the squares of 1 to 5. One way is to write each calculation out.

It works, but nothing about it scales: for the squares up to 500 you would write 500 expressions, and a typo in one of them hides among the rest. Loops exist so the *rule* is written once and the computer repeats it.

python

print(1 * 1, 2 * 2, 3 * 3, 4 * 4, 5 * 5)   # 1 4 9 16 25

Cost: Work and chance of mistakes grow with every extra item, instead of staying constant.

The concept

Values, variables and operators

A variable is a name attached to a value: x = 5 makes the name x refer to 5. Every value has a type, which decides what you can do with it.

int: whole numbers, of any size (Python never overflows). float: numbers with a decimal point, stored approximately.
str: text in quotes. bool: True or False.
Arithmetic: + - *, true division / (always a float), floor division // (rounds down), remainder %, power **.
Comparison: == != < <= > >= give a bool. Logic: and, or, not.
= assigns a value; == asks whether two values are equal. Mixing them up is the most common beginner bug.
Truthiness: 0, 0.0, "" (empty text), [] and None count as false in an if; almost everything else counts as true.

Implementation

Arithmetic and types, with the surprises

Predict each output before reading the comment. Three of them surprise almost everyone: floor division with negatives, the remainder with negatives, and 0.1 + 0.2.

python

a, b = 7, 2
print(a + b, a - b, a * b)   # 9 5 14
print(a / b)   # 3.5
print(a // b, a % b)   # 3 1
print(a ** b)   # 49
print(-7 // 2, -7 % 2)   # -4 1
print(type(a).__name__, type(a / b).__name__, type("hi").__name__, type(True).__name__)   # int float str bool
print(0.1 + 0.2 == 0.3)   # False
print(abs(0.1 + 0.2 - 0.3) < 1e-9)   # True
print( ** )

See it move

A loop with a decision inside

for x in numbers: takes the values one at a time. Inside, an if decides which branch to run. Step through and watch the variable x, the test x % 2 == 0, and the label that gets recorded. This pattern (loop, test, act) appears in almost every program.

Worked by hand

Tracing a loop by hand

The best way to understand a loop is to write a table of the variables after each pass. Take total = 0 followed by for i in range(1, 6): total += i.

pass	i	total before	total after (total += i)
1	1	0	1
2	2	1	3
3	3	3	6
4	4	6	10
5	5	10	15

1
Why i stops at 5
range(1, 6) starts at 1 and stops before 6, so it produces 1, 2, 3, 4, 5. The stop value is never included. This single fact causes most off-by-one errors.
2
The shape to remember

Implementation

Decisions and repetition

if/elif/else runs exactly one branch. for repeats over a collection or a range; while repeats as long as a condition holds. break leaves a loop early, and continue skips to the next pass.

Plan in plain steps

pseudocode

if condition A: do this
elif condition B: do that
else: do the other

for each item in a collection: do something with the item
while a condition holds: do something, and change something so it eventually stops

python

def classify(x):
    if x < 0:
        return "negative"
    elif x == :
         
    :
         

((-), (), ())   

total = 
 i  (, ):
    total += i
(total)   

n, digits = , 
 n > :
    n //= 
    digits += 
(digits)   

 x  (, ):
     x %  == :
        (x)

Implementation

Functions, text, and reading input

A function names a group of steps. It takes parameters, may have default values, and sends a result back with return. Text works like a list of characters: you can index it, slice it, and call methods on it.

python

def area(w, h=1):
    return w * h

print(area(3, 4), area(5))   # 12 5

s = "competitive"
print(len(s), s[0], s[-1], s[2:5])   # 11 c e mpe
print(s.upper(), s.count("t"))   # COMPETITIVE 2
print(s.find("pet"), s.find("xyz"))   # 3 -1
name, score = "Ana", 91.5
print(f"{name} scored {score:.1f}")   
(.())   
(.([, , ]))   

line =       
nums = ((int, line.()))
(nums, (nums))

Complexity

What the basic operations cost

You do not need formal analysis yet, but build the habit of noticing how many times something runs. The Complexity lesson goes deeper.

Arithmetic, comparison, variable assignment

time O(1)space O(1)

A fixed amount of work regardless of the numbers' size (for ordinary-sized ints).

A single for or while loop over n items

time O(n)space O(1)

The body runs once per item.

A loop inside a loop

time O(n²)space O(1)

The inner body runs n times for each of the n outer passes.

len(s), s[i]

time O(1)space O(1)

Text stores its length and can jump to any position.

s.find(x), x in s, s.count(x)

time O(n)space O(1)

They may scan the whole text.

Building a text with s += ... in a loop

time up to O(n²)space O(n)

Strings cannot change, so each += can copy everything so far. Collect pieces in a list and once.

Edge cases

Edge cases and surprises

Dividing by zerox / 0 and x // 0 raise ZeroDivisionError. Check the divisor first if it can be 0.
Negative numbers with // and %// rounds down and % stays non-negative for a positive divisor. Do not assume C-style truncation.
Float equalityNever test floats with ==. Use a tolerance, or use integers (for example work in cents).
Empty text or empty input"".split() gives an empty list, so max(...) of it would fail. Handle the empty case explicitly.
Off-by-one in rangerange(n) gives 0 to n − 1; range(1, n + 1) gives 1 to n. Check the first and last values on paper.
Strings are immutables[0] = "x" is an error. Build a new string instead.

Common mistakes

Mistakes to avoid

Writing if x = 5: (assignment) instead of if x == 5: (comparison).
Python rejects the first form, but in other languages it silently compiles. Read == as “is equal to”.
Expecting / to give a whole number.
/ always returns a float. Use // when you want a whole number.
Forgetting to convert input text to numbers.
"3" + "5" is "35", not 8. Convert with int(...) first.
An infinite while loop.
Make sure something in the body moves the condition toward False. Add a temporary print to watch it.
Inconsistent indentation.

Recognize it in a contest

How to spot a “just implement it” problem

Many contest problems, especially the first ones in a set, need no clever algorithm. They test whether you can turn a description into correct code.

Reach for it when the problem says or implies

The statement describes exactly what to do, step by step: read numbers, apply a rule, print a result.
The input is small (a few hundred values at most), so even a clumsy loop passes.
The tools needed are arithmetic, if, a loop, and basic text handling: //, %, slicing, split.
The difficulty is in details: formats, edge cases, off-by-one, careful reading.
Typical names: “implementation”, “simulation”, “math”, “strings”, “brute force”.

Look elsewhere when

Worked problem

Is a number a palindrome?

The problem

Return True if an integer reads the same forwards and backwards (121 is, -121 is not because of the minus sign, 10 is not). Do it without converting to text.

Negative numbers can never be palindromes: return False at once.
Build the reversed number digit by digit. x % 10 is the last digit; x // 10 removes it.
Each pass: shift the reversed number left (rev * 10), add the digit, and drop the digit from x.
At the end compare the reversed value with the original.

python

def is_palindrome_number(x):
    if x < 0:
        return False
    original, rev = x, 0
    while x > 0:
        rev = rev * 10 + x % 10
        x //= 10
    return original == rev

print(is_palindrome_number(121))   # True
print(is_palindrome_number(-121))   # False
print(is_palindrome_number(10))   # False

Worked problem

Summarise a line of input

The problem

A line contains whitespace-separated integers. Return how many there are, their sum, their maximum and how many are even.

Split the line into pieces and convert each piece to an int.
Use an accumulator evens that starts at 0 and increases for every even value.
len, sum and max are built in. Return everything together.

python

def summarize(line):
    nums = list(map(int, line.split()))
    evens = 0
    for x in nums:
        if x % 2 == 0:
            evens += 1
    return len(nums), sum(nums), max(nums), evens

print(summarize("3 8 5 12"))   # (4, 28, 12, 2)
print(summarize("7"))   # (1, 7, 7, 0)

Wrap-up

Remember this

A program remembers values (variables), chooses (if/elif/else) and repeats (for, while).
Know your operators: / is a float, // rounds down, % is the remainder, and = is not ==.
range(a, b) stops before b; most off-by-one errors start there.
Floats are approximate; Python integers are exact and unlimited.
Functions name a group of steps; split and map(int, ...) turn text input into numbers.

Cheat sheet

Division: / true · // floor · % remainder · ** power
Negatives: -7 // 2 = -4 and -7 % 2 = 1
range: range(a, b) includes a, excludes b
Falsy: 0, 0.0, "", [], None
Floats: compare with abs(x − y) < 1e-9
Input line: list(map(int, line.split()))

Top traps to avoid

Writing if x = 5: (assignment) instead of if x == 5: (comparison).
Expecting / to give a whole number.
Forgetting to convert input text to numbers.

Mastery check

0 of 15 answered

Answer from understanding, not memory of the page. You need 12 of 15. Each answer is explained, and you can retry as often as you like.

1.What does -7 // 2 evaluate to in Python?
2.How many times does the body of for i in range(2, 7): run?
3.Why is 0.1 + 0.2 == 0.3 False in Python?
4.Which of these counts as False inside an if?
5.For s = "competitive", what is s[2:5]?
6.Which statement describes a typical “implementation” problem?
7.What does 7 % -3 evaluate to in Python?
8.What does print(2 ** 10, 2 ** -1) print?
9.After x = 5 and then x += 2 * 3, what is x?
10.What type is the result of int('12') + float('0.5')?
11.What does print(10 // 3, 10 % 3, -10 // 3) print?
12.x = 'hello'. What does print(x[1:-1]) print?
13.What does print(bool(''), bool('0'), bool([])) print?
14.Why can a is b be False even when a == b is True, for two equal lists?
15.What does print(round(1.23456, 2), 7 / 2) print?

Start an accumulator (total = 0), update it inside the loop, use it after the loop. Counting, summing, finding a maximum: all of them follow this shape.

"".join(...)

Python Basics

After this lesson you will be able to

Builds on

Unlocks

A program is a recipe

Doing each calculation by hand

Values, variables and operators

Arithmetic and types, with the surprises

A loop with a decision inside

Tracing a loop by hand

Decisions and repetition

Functions, text, and reading input

What the basic operations cost

Edge cases and surprises

Mistakes to avoid

How to spot a “just implement it” problem

Is a number a palindrome?

Summarise a line of input

Wrap-up

Remember this

Cheat sheet

Top traps to avoid

Mastery check

Practice this topic

Warm-up3 problems

Core4 problems

Application4 problems

Challenge1 problem

Reading the code

Reading the code

Reading the code