Programming

Primitive Data Types

Integers (int)
Definition: Whole numbers without decimal points, positive or negative.
Examples: -5, 0, 42, 1000
Operations: Addition: 5 + 3 = 8, Subtraction: 10 - 4 = 6, Multiplication: 6 * 7 = 42, Division (integer): 17 / 5 = 3 (truncated), Modulo (remainder): 17 % 5 = 2, Power: 2 ** 3 = 8
Use cases: Counting items, indexing arrays, IDs

Floating-Point Numbers (float)
Definition: Numbers with decimal points.
Examples: 3.14, -0.5, 2.0, 9.99
Operations: Same as integers, but keep decimals: 5.5 + 2.3 = 7.8, 10.0 / 3.0 = 3.333...
Caution: Floating-point arithmetic can be imprecise due to how computers represent decimals. 0.1 + 0.2 = 0.30000000000000004 (not exactly 0.3!)
Use cases: Scientific calculations, measurements, money (though special types are better for money)

Booleans (bool)
Definition: Values that are either True or False.
Examples: True, False
Operations: AND: True AND True = True, True AND False = False; OR: True OR False = True, False OR False = False; NOT: NOT True = False, NOT False = True
Use cases: Conditions, flags, yes/no questions

Characters and Strings (char, string)
Character: Single letter, digit, or symbol. Examples: 'a', 'Z', '5', '@'
String: Sequence of characters. Examples: "Hello", "Python", "user@email.com"
Operations: Concatenation: "Hello" + " World" = "Hello World", Repetition: "Ha" * 3 = "HaHaHa", Length: length("Hello") = 5, Indexing: "Hello"[0] = 'H', Slicing: "Hello"[1:4] = "ell"
Use cases: Text, names, messages, user input

IF Statements

Basic syntax: if condition: # execute this code if condition is True

Example: age = 18; if age >= 18: print("You can vote")

IF-ELSE

Execute one block if True, another if False: if condition: # execute if True; else: # execute if False

Example: temperature = 25; if temperature > 30: print("It's hot"); else: print("It's not hot")

IF-ELIF-ELSE

Multiple conditions: if condition1: # execute if condition1 is True; elif condition2: # execute if condition1 is False but condition2 is True; elif condition3: # execute if condition1 and condition2 are False but condition3 is True; else: # execute if all conditions are False

Example: Grade classification. score = 85; if score >= 90: grade = 'A'; elif score >= 80: grade = 'B'; elif score >= 70: grade = 'C'; elif score >= 60: grade = 'D'; else: grade = 'F'; print(f"Your grade is {grade}") # Output: Your grade is B

Nested Selection

IF statements inside IF statements: age = 20; has_license = True; if age >= 18: if has_license: print("You can drive"); else: print("You need a license"); else: print("You're too young to drive")

FOR Loops

Execute code a specific number of times:

Range-based: for i in range(5): print(i) # Output: 0, 1, 2, 3, 4

Range with start and end: for i in range(1, 6): print(i) # Output: 1, 2, 3, 4, 5

Range with step: for i in range(0, 10, 2): print(i) # Output: 0, 2, 4, 6, 8

Iterating through collections: fruits = ["apple", "banana", "orange"]; for fruit in fruits: print(fruit) # Output: apple, banana, orange

WHILE Loops

Execute code while condition is True: while condition: # execute this code; # must eventually make condition False (or break)

Example: Count to 5: count = 1; while count <= 5: print(count); count = count + 1 # Output: 1, 2, 3, 4, 5

Example: User input validation: password = ""; while password != "secret": password = input("Enter password: "); print("Access granted")

Warning: Infinite loops run forever if condition never becomes False! # INFINITE LOOP - Don't run! while True: print("This never stops")

Loop Control

BREAK: Exit loop immediately. Example: for i in range(10): if i == 5: break; print(i) # Output: 0, 1, 2, 3, 4 (stops at 5)

CONTINUE: Skip rest of current iteration, start next. Example: for i in range(5): if i == 2: continue; print(i) # Output: 0, 1, 3, 4 (skips 2)

Nested Loops

Loops inside loops: for i in range(3): for j in range(2): print(f"i={i}, j={j}")

Output: i=0,j=0; i=0,j=1; i=1,j=0; i=1,j=1; i=2,j=0; i=2,j=1

Use case: Multiplication table: for i in range(1,4): for j in range(1,4): print(f"{i} x {j} = {i*j}")

Defining Functions

Basic syntax: def function_name(parameters): # function body; return result

Example: Calculate area of rectangle: def calculate_area(length, width): area = length * width; return area; result = calculate_area(5, 3); print(result) # Output: 15

Parameters and Arguments

Parameters: Variables in function definition; Arguments: Values passed when calling function. def greet(name, age): # name and age are parameters; message = f"Hello {name}, you are {age} years old"; return message; output = greet("Alice", 25) # "Alice" and 25 are arguments

Return Values

Functions can return values: def add(a, b): return a + b; result = add(5, 3) # result = 8

Functions can return nothing (None): def print_message(text): print(text); # no return statement → returns None; result = print_message("Hello") # result is None

Functions can return multiple values: def get_min_max(numbers): minimum = min(numbers); maximum = max(numbers); return minimum, maximum; min_val, max_val = get_min_max([3, 7, 2, 9, 1]) # min_val = 1, max_val = 9

Scope

Variables defined inside functions are local: def my_function(): x = 10 # local variable; print(x); my_function() # prints 10; print(x) # ERROR! x doesn't exist outside function

Global variables accessible everywhere: x = 10 # global variable; def my_function(): print(x) # can read global; my_function() # prints 10; print(x) # prints 10

Arrays

Definition: An array is a collection of elements of the same type stored in contiguous memory locations, accessed by index.

Creating arrays: numbers = [10, 20, 30, 40, 50]; names = ["Alice", "Bob", "Carol"]

Accessing elements (0-indexed): numbers[0] # 10 (first element); numbers[2] # 30 (third element); numbers[-1] # 50 (last element)

Modifying elements: numbers[1] = 25 # numbers is now [10, 25, 30, 40, 50]

Common operations: len(numbers) # 5; append (add to end): numbers.append(60) # [10, 25, 30, 40, 50, 60]; insert at position: numbers.insert(2, 99) # [10, 25, 99, 30, 40, 50, 60]; remove by value: numbers.remove(30) # [10, 25, 99, 40, 50, 60]; remove by index: del numbers[2] # [10, 25, 40, 50, 60]; check if exists: 40 in numbers # True; 100 in numbers # False

Multi-Dimensional Arrays

Arrays of arrays. 2D array (matrix): matrix = [[1,2,3],[4,5,6],[7,8,9]]; Accessing elements: matrix[0][0] = 1; matrix[1][2] = 6; matrix[2][1] = 8

Use cases: Grids, game boards, tables, images (pixels)

Why It Matters

Different algorithms have different efficiencies. Sorting 10 items? All algorithms are fast. Sorting 1,000,000 items? Big differences!

Big O helps us: Compare algorithms, Predict performance, Choose the right approach

Common Big O Classifications

O(1) - Constant Time
Runtime doesn't depend on input size. Example: Array access. numbers[5] # Always takes same time, regardless of array size. Graph: Flat line.

O(log n) - Logarithmic Time
Runtime grows slowly as input size increases. Example: Binary search. 1,000 items → ~10 operations; 1,000,000 items → ~20 operations. Graph: Slowly increasing curve.

O(n) - Linear Time
Runtime grows proportionally to input size. Example: Linear search. for item in list: if item == target: return True. Worst case: Check every element. 1,000 items → 1,000 operations; 1,000,000 items → 1,000,000 operations. Graph: Straight diagonal line.

O(n log n) - Linearithmic Time
Efficient sorting algorithms. Example: Merge sort, Quick sort. 1,000 items → ~10,000 operations; 1,000,000 items → ~20,000,000 operations. Graph: Curve steeper than O(log n) but flatter than O(n²).

O(n²) - Quadratic Time
Runtime grows with square of input size. Example: Bubble sort (nested loops). for i in range(len(list)): for j in range(len(list)): # Compare elements. 1,000 items → 1,000,000 operations; 1,000,000 items → 1,000,000,000,000 operations. Graph: Steep exponential curve.

O(2ⁿ) - Exponential Time
Runtime doubles with each added input. Example: Recursive Fibonacci (naive implementation). Extremely slow for large inputs. Graph: Nearly vertical curve.

Bubble Sort

Idea: Repeatedly swap adjacent elements if they're in wrong order.

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]

How it works: Pass 1: Largest element "bubbles" to end; Pass 2: Second largest bubbles to second-to-last position; Continue until sorted

Example: [5, 2, 8, 1, 9] → Pass 1: [2, 5, 1, 8, 9]; Pass 2: [2, 1, 5, 8, 9]; Pass 3: [1, 2, 5, 8, 9]

Time Complexity: O(n²), Space Complexity: O(1), When to use: Small datasets, educational purposes

Selection Sort

Idea: Find minimum element, swap with first position. Repeat for remaining elements.

def selection_sort(arr):
    n = len(arr)
    for i in range(n):
        min_idx = i
        for j in range(i+1, n):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]

Example: [29, 10, 14, 37, 13] → Find min (10), swap: [10, 29, 14, 37, 13]; Find min of rest (13), swap: [10, 13, 14, 37, 29]; Find min of rest (14), already in place; Find min of rest (29), swap: [10, 13, 14, 29, 37]

Time Complexity: O(n²), Space Complexity: O(1)

Insertion Sort

Idea: Build sorted array one element at a time by inserting each element in correct position. Like sorting playing cards in your hand.

def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key

Time Complexity: O(n²) worst case, O(n) best case (already sorted), Space Complexity: O(1), When to use: Small datasets, nearly sorted data

Merge Sort

Idea: Divide array in half, recursively sort each half, merge sorted halves.

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

def merge(left, right):
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result.extend(left[i:])
    result.extend(right[j:])
    return result

Example: [38,27,43,3,9,82,10] → Divide, recursively sort, merge

Time Complexity: O(n log n), Space Complexity: O(n), When to use: Large datasets, guaranteed O(n log n) performance

Quick Sort

Idea: Pick pivot, partition array so smaller elements on left, larger on right. Recursively sort partitions.

Time Complexity: O(n log n) average, O(n²) worst case, Space Complexity: O(log n), When to use: Large datasets, typically fastest in practice

Recursive Structure

Must have: Base case: Condition where recursion stops; Recursive case: Function calls itself with simpler input

Without base case: Infinite recursion (stack overflow)

Example: Factorial

Definition: n! = n × (n-1) × (n-2) × ... × 1

def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n - 1)

Trace factorial(4): factorial(4) = 4 * factorial(3) = 4 * (3 * factorial(2)) = 4 * (3 * (2 * factorial(1))) = 4 * (3 * (2 * 1)) = 4 * 6 = 24

Example: Fibonacci

Definition: fib(n) = fib(n-1) + fib(n-2)

def fibonacci(n):
    if n == 0:
        return 0
    if n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)

fibonacci(5): fib(5)=fib(4)+fib(3)=(fib(3)+fib(2))+(fib(2)+fib(1))=...=5

Problem: Many redundant calculations! fib(2) calculated multiple times. Better: Use iterative approach or memoization.

When to Use Recursion

Good for: Tree traversals, Divide and conquer algorithms, Problems with recursive structure (Fibonacci, factorials), Backtracking (solving puzzles)

Avoid when: Simple iteration works better, Deep recursion (stack overflow risk), Too many redundant calculations (unless using memoization)

Reading Files

Open file: file = open("data.txt", "r") # "r" = read mode

Read entire file: content = file.read(); print(content); file.close()

Read line by line: file = open("data.txt", "r"); for line in file: print(line.strip()) # strip() removes newline; file.close()

Better: Using with statement (auto-closes file): with open("data.txt", "r") as file: content = file.read(); print(content) # File automatically closed

Writing Files

Write mode (overwrites file): with open("output.txt", "w") as file: file.write("Hello, World!\n"); file.write("Second line\n")

Append mode (adds to end): with open("output.txt", "a") as file: file.write("Third line\n")

File Modes

"r": Read (default), "w": Write (overwrites), "a": Append (adds to end), "r+": Read and write, "b": Binary mode (e.g., "rb" for reading binary)

Processing CSV Files

CSV (Comma-Separated Values): Name,Age,Grade; Alice,20,A; Bob,21,B; Carol,19,A

Reading CSV: import csv; with open("students.csv", "r") as file: reader = csv.reader(file); for row in reader: print(row) # ['Name','Age','Grade'], ['Alice','20','A'], ...

Writing CSV: import csv; data = [['Name','Age','Grade'], ['Alice',20,'A'], ['Bob',21,'B']]; with open("students.csv", "w", newline='') as file: writer = csv.writer(file); writer.writerows(data)