Chapter 2 — Introduction To Python

What is Python? Python is a high-level, interpreted, general-purpose programming language designed for readability and rapid development. Created by Guido van Rossum and first released in 1991, Python supports multiple programming paradigms (procedural, object-oriented, and functional) and emphasizes clear, readable code using indentation for block structure.

Key characteristics — Python is:

• Interpreted: Code runs via an interpreter (no separate compilation step needed).
• Dynamically typed: Variable types are determined at runtime.
• Garbage-collected: Automatic memory management for unused objects.
• High-level: Provides built-in data types and abstractions (strings, lists, dictionaries, etc.).
• Batteries-included: Large standard library and many third-party packages for web development, data science, automation, and more.

Where Python is used (real-life domains): web applications (Django, Flask), data analysis and machine learning (Pandas, NumPy, scikit-learn), automation and scripting, DevOps tools, scientific computing, GUI apps, IoT (Raspberry Pi), education, and more.

Basic building blocks — Python programs are made of:

• Variables and basic data types: int, float, str, bool
• Compound data structures: list, tuple, set, dict
• Control flow: if, for, while
• Functions: reusable blocks defined with def (or lambda for small anonymous functions)
• Modules and packages: code organization and reuse across files
• Exception handling: try/except for runtime errors
• File I/O: reading/writing text and binary files

Simple example (structure and syntax):

def greet(name):
    if name:
        return 'Hello, ' + name
    else:
        return 'Hello, World'

print(greet('Anita'))  # Hello, Anita

Advantages in learning and industry: Python's simple syntax makes it ideal for beginners. Its extensive ecosystem and community support make it a first-choice language for prototyping, automation, and data work. Python 3 is the recommended version for modern code.

Execution modes: interactive mode (REPL) for quick experiments and script mode (run .py files) for full programs. Use virtual environments to manage project-specific packages.

Best practices (short): write readable code with meaningful names, follow indentation rules, prefer list/dict comprehensions for concise operations, handle exceptions where appropriate, and keep functions small and single-purpose.

What and Why

Python is a high-level, interpreted programming language used for scripting, web development, data analysis, automation and education. To write and run Python programs you need the Python interpreter installed and an editor or Integrated Development Environment (IDE) to write, run and debug code.

Choose Python Version

Use Python 3 (current stable release). Python 2 is obsolete. Always choose a stable 3.x release compatible with libraries you need.

Installation — Quick Steps by OS

1. Windows
   1. Go to https://www.python.org/downloads/ and download the Windows installer for Python 3.x.
   2. Run the installer. Important: check "Add Python to PATH" before clicking "Install Now".
   3. After install, verify in Command Prompt:

      python --version
      pip --version

2. macOS
   1. Install using the official installer from python.org or use Homebrew:

      /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
      brew install python

   2. Verify:

      python3 --version
      pip3 --version

3. Linux (Ubuntu/Debian)
   1. Use package manager:

      sudo apt update
      sudo apt install python3 python3-pip

   2. Verify:

      python3 --version
      pip3 --version

Virtual Environments (recommended)

Use venv to create isolated environments so project packages don't clash:

python3 -m venv env        # create environment
# Activate on macOS/Linux:
source env/bin/activate
# Activate on Windows (PowerShell):
env\Scripts\Activate.ps1
# Install packages inside env:
pip install requests

IDEs and Editors — Options & When to Use

• IDLE — comes with Python, simple for beginners.
• Thonny — beginner-friendly, shows how code executes step-by-step.
• VS Code — lightweight editor with Python extension: good for all levels, supports debugging, virtual envs, Jupyter.
• PyCharm (Community) — full-featured IDE for larger projects with code inspection and project management.
• Jupyter Notebook / Lab — interactive notebooks, ideal for data analysis, visualization and teaching.
• Spyder — scientific IDE (similar to MATLAB) used for data science.

Configuring an IDE

1. Install the IDE (download or via package manager).
2. In the IDE settings, select the Python interpreter (system python or virtual environment python executable).
3. Install necessary extensions/plugins (e.g., Python extension in VS Code).
4. Configure linter and formatter (optional) like flake8 or black.

First Program & Testing

Create a file hello.py with:

print("Hello, world!")

Run from terminal:

python hello.py   # or python3 hello.py

Troubleshooting Tips

• If "python" command not found, confirm PATH or use full path or "python3".
• Use pip list or pip3 list to check installed packages:

  pip list

• If multiple Python versions exist, specify the correct interpreter in IDE settings.

Security & Best Practices

• Keep Python and packages updated:

  pip install --upgrade pip
  pip install --upgrade 

• Use virtual environments for each project.
• Install packages from trusted sources (PyPI) and review dependencies.

Summary

Installing Python is straightforward: download or use a package manager, verify installation, create virtual environments, choose an IDE suitable for your needs, configure the interpreter, and run a test program. For classroom learning, Thonny or VS Code are often the best starting points.

Overview
Python is an interpreted, high-level, dynamically typed language. The Python interpreter reads your source code, translates it into an intermediate form, and executes it. The common reference implementation is CPython, which compiles Python source to bytecode and executes that bytecode on a Python Virtual Machine (PVM).

Interpreter vs Compiler (brief)

• Compiler: translates source code fully into machine code before execution (example: C).
• Interpreter: translates and executes code in smaller steps at runtime (example: Python). CPython uses a hybrid approach: it first compiles source to bytecode, then interprets bytecode.

Execution pipeline (step-by-step)

• Source code: the .py file you write.
• Lexical analysis / Tokenization: source is broken into tokens (keywords, identifiers, literals, operators).
• Parsing: tokens are converted to an Abstract Syntax Tree (AST) that represents the program structure.
• Bytecode compilation: AST is compiled into bytecode (a lower-level, platform-independent instruction set).
• Python Virtual Machine (PVM): the PVM executes bytecode using an interpreter loop (fetch-decode-execute) and manages runtime structures like stack frames and namespaces.

Runtime concepts

• Stack frames: each function call creates a frame containing local variables, instruction pointer, and evaluation stack.
• Namespaces: collections that map names to objects. Typical namespaces are local, enclosing, global, and built-in (LEGB rule for name resolution).
• Dynamic typing: variables are names bound to objects; types belong to objects and can change at runtime.
• Memory management: objects are allocated on the heap; CPython uses reference counting plus a cyclic garbage collector to reclaim unreachable cycles.
• Errors: syntax errors are caught at parsing/compilation time; exceptions (runtime errors) occur during execution.

Interactive mode vs Script mode

• Interactive (REPL): enter statements/expression and get immediate results; good for experimentation and learning.
• Script mode: run .py files using the interpreter (python file.py) for programs and automation.

Practical notes
Because Python compiles to bytecode, you may see .pyc files in __pycache__ created by CPython to speed up subsequent imports. Alternative interpreters (PyPy, Jython, IronPython) provide different execution strategies (e.g., JIT compilation) but keep the same high-level semantics.

Small example of the pipeline (visualized)

source:   x = 10
parser:   AST nodes for assignment and literal
compile:  bytecode (LOAD_CONST 10; STORE_NAME 'x')
PVM:      execute bytecode, allocate object 10, bind name 'x' to it

What are Comments?
Comments are non-executable text in a program used to explain code, leave notes for programmers, or document behaviour. Python ignores comments while running the program.

Types of comments in Python

• Single-line comment: starts with #. Everything after # on the same line is a comment. Example: # This is a comment
• Inline comment: placed after a statement on the same line: x = 5 # set x to 5
• Multiline documentation strings (docstrings): triple quotes """...""" or '''...''' immediately after a module, function or class header. They are string literals used for documentation and are accessible at runtime via __doc__. (Technically they are strings, not comments.)

Best practices for comments

• Keep comments short, meaningful and up to date.
• Use comments to explain why something is done, not what simple statements do.
• Use docstrings for public functions/classes/modules to document purpose, parameters and return values.

What is Indentation?
In Python indentation (leading spaces or tabs) defines blocks of code (the body of functions, loops, if-else, classes). Python uses indentation instead of braces ({ }) used in many other languages.

Key indentation rules

• After a statement that ends with a colon (for, if, while, def, class, try, with, etc.), the following indented lines form the block associated with that statement.
• All statements in the same block must have the same indentation level.
• Mixing tabs and spaces in indentation can cause IndentationError or inconsistent behavior — PEP 8 recommends using 4 spaces per indent level.

Example: correct vs incorrect indentation

# Correct indentation
if x > 0:
    print('Positive')
    x -= 1
else:
    print('Non-positive')

# Incorrect indentation (will raise IndentationError or give unexpected block)
if x > 0:
print('Positive')  # Not indented

Docstrings example

def add(a, b):
    """Return the sum of a and b.

    Parameters:
      a (int): first number
      b (int): second number
    Returns:
      int: a + b
    """
    return a + b

Why good indentation and comments matter

• Indentation makes logical structure visible, improving readability and preventing logic errors.
• Good comments and docstrings make code maintainable and easier for others (or yourself later) to understand.

Quick tips

• Use an editor that shows invisible characters and converts tabs to spaces.
• Follow PEP 8: 4 spaces per indentation level, and short, clear docstrings.
• Comment intent, not obvious operations; keep comments synchronized with code changes.

Keywords are reserved words in Python that have a predefined meaning to the interpreter and cannot be used as names (identifiers) for variables, functions, classes, or other user-defined items. Examples include: if, else, for, while, def, class, import, return, True, False, None, etc. The full list of keywords can be obtained in Python using import keyword; keyword.kwlist.

Identifiers are names given by the programmer to entities like variables, functions, classes, modules, and objects. Identifiers must follow certain rules so the interpreter can correctly recognize them:

• Must start with a letter (A–Z or a–z) or an underscore (_).
• Can contain letters, digits (0–9) and underscores only: no spaces or other special characters.
• Are case-sensitive: age and Age are different identifiers.
• Cannot be a Python keyword or a built-in constant like True, False, None (they are reserved).
• There is no practical length limit, but keep names readable.

Formal pattern (regular expression) for a valid identifier: ^[A-Za-z_][A-Za-z0-9_]*$

Naming conventions (best practices) (not enforced by the interpreter but recommended):

• snake_case for variable and function names (e.g., student_name).
• PascalCase / CapWords for class names (e.g., StudentRecord).
• Use UPPERCASE for constants (e.g., MAX_SPEED = 100).
• Single leading underscore (_name) indicates internal use; double leading underscores (__name) trigger name mangling in classes.

Why this matters: Using meaningful, valid identifiers makes code readable and avoids syntax errors. Attempting to use a keyword as an identifier or starting an identifier with a digit will raise a syntax error.

Quick examples (code):

# Valid identifiers
student_name = "Asha"
_age = 17
score1 = 95

# Invalid identifiers (cause errors)
# 1name = 10      # starts with digit -> SyntaxError
# total marks = 100  # space in name -> invalid
# for = 5         # 'for' is a keyword -> SyntaxError

Special identifiers: Names surrounded by double underscores (e.g., __init__, __name__) have special meaning in Python (magic methods or module attributes) but are not keywords; avoid redefining them unless you know what you are doing.

What is a variable?
A variable is a name (label) that refers to a value stored in the computer's memory. In Python, variables are created when you assign a value to a name. Variables make programs readable and allow data to be reused and changed.

Assignment operator
The single equals sign = is the assignment operator. The right-hand side (an expression) is evaluated first, and the result is bound to the name on the left-hand side.

Basic rules for naming variables

• Use letters, digits and underscores only: age_11, studentName.
• Must not start with a digit: _score or score1 are valid, 1score is not.
• Cannot use Python keywords (like for, if, class).
• Prefer meaningful names and use snake_case for readability: total_marks, average_score.

Dynamic typing
Python is dynamically typed: a variable can be bound to values of different types during program execution. Example: x = 5 then x = 'five' is allowed.

Common assignment forms

• Simple: x = expression
• Multiple assignment (unpacking): a, b = 10, 20
• Chain assignment: x = y = 0 (both refer to the same value)
• Augmented assignment: count += 1 (short for count = count + 1)
• Swap using tuple unpacking: a, b = b, a

Mutability vs immutability (brief)
Immutable types (int, float, str, tuple) cannot be changed in place; assignment creates a new object and binds the name to it. Mutable types (list, dict, set) can be changed in place; two variable names can reference the same mutable object (aliasing).

Memory analogy
Think of a variable as a labeled box. Assignment places a value inside the box or points the label to an object. Reassigning changes which object the label points to.

Best practices

• Use clear, descriptive names and follow naming conventions.
• Initialize variables before use.
• Be careful with mutable objects—copy if you need independent copies.
• Use augmented assignment for concise updates and potentially better performance.

Small code examples (illustrative)

age = 15                     # store an integer
name = 'Asha'                 # store a string
balance = float(input())      # convert input and assign
x, y = 5, 10                  # multiple assignment
x, y = y, x                   # swap values
scores = [10, 20]             # mutable object (list)
scores2 = scores              # aliasing: both names refer to same list
scores.append(30)             # modifies the list seen by both names
count = 0
count += 1                    # augmented assignment

This covers the core ideas of variables and assignment in Python for Class 11 Informatics Practices.

What are Data Types?
A data type specifies the kind of values that can be stored and the operations that can be performed on them. Python is dynamically typed (you don’t declare types explicitly) and strongly typed (operations check types).

Common built-in data types in Python:

• Numeric
  • int — integers, e.g., 42, -7
  • float — floating-point numbers (decimals), e.g., 3.14, -0.5
  • complex — complex numbers with real and imaginary parts, e.g., 2+3j
• Boolean — True or False (capitalized)
• String — sequence of characters enclosed in single, double or triple quotes, e.g., 'hello', "world", '''multi-line'''
• NoneType — None (represents absence of value)

Literals
Literals are fixed values written directly in code. Examples: 100, 3.5, 'CBSE', True, None.

Numeric literal forms

• Decimal: 255
• Binary: 0b1010 (prefix 0b)
• Octal: 0o377 (prefix 0o)
• Hexadecimal: 0xFF (prefix 0x)
• Underscores allowed for readability: 1_000_000
• Imaginary: 3j or 2+3j

String literals

• Single or double quotes: 'a' or "a"
• Triple quotes for multi-line strings: '''multi\nline'''
• Raw strings to ignore escape sequences: r"C:\\new_folder"

Boolean and None literals

• True and False (note the capitalization)
• None represents no value

Type checking and conversion

• type(x) returns the type of x
• isinstance(x, T) checks whether x is of type T
• Explicit conversion (casting): int(), float(), str(), complex()
• Implicit (coercion) example: int + float -> float

Important properties

• Immutability: numbers and strings are immutable (operations create new objects)
• Booleans are a subtype of integers: True == 1, False == 0

Small code examples

age = 16                # int literal
price = 199.99           # float literal
name = 'Asha'            # string literal
flag = True              # boolean literal
z = 3 + 4j               # complex literal

print(type(age))         # >> <class 'int'>
print(int(3.9))          # >> 3  (casting truncates toward 0)
print(1 + 2.0)           # >> 3.0  (int + float -> float)

Rules & tips

• String concatenation: 'Hello' + ' ' + 'World' -> 'Hello World'
• String repetition: 'ha' * 3 -> 'hahaha'
• Division behaviors: / gives float, // gives integer floor division, % gives remainder
• Use underscores in long numeric literals for readability: 3_500_000

Where used in real life? Data types allow programs to model real-world data correctly — e.g., ages as integers, prices as floats, product codes as strings, feature flags as booleans, sensor data as floats or lists of floats.

Overview: In Python, input and output (I/O) means getting data from the user (input) and showing results on the screen or writing them out (output). The two most common functions are input() for reading from the keyboard and print() for writing to the console.

input(): input(prompt) displays an optional prompt and returns the user-entered data as a string. Because it always returns a string, you must convert it to numeric types when needed using int(), float(), etc. Example: age = int(input('Enter age: ')). Handle incorrect input using try/except to avoid ValueError.

print(): print(value1, value2, ..., sep=' ', end='\n', file=sys.stdout, flush=False) prints one or more values separated by sep and terminated by end. Common parameters:
- sep: string inserted between values (default a single space),
- end: string appended after the last value (default newline).
For formatted output use f-strings (Python 3.6+): print(f"Name: {name}, Score: {score:.2f}") or format() / % formatting.

Reading multiple values: Use split() to divide an input string and map() to convert types, e.g. a, b = map(int, input().split()) reads two integers from one line. For lists: nums = list(map(float, input().split())).

Common pitfalls: forgetting to convert types (so arithmetic on strings concatenates instead of adds), not trimming whitespace, and not handling exceptions. For numeric precision, control display with format specifiers like {value:.2f} to show two decimal places.

Good practice: Validate inputs, give clear prompts, convert types explicitly, and format outputs for readability (labels, fixed decimal places, alignment when printing tables).

What are operators and expressions?

An operator is a symbol that performs an operation on one or more operands (values or variables). An expression is a combination of operands and operators that Python evaluates to produce a value.

Types of operators in Python (with purpose)

• Arithmetic: +, -, *, /, // (floor division), % (modulo), ** (exponentiation) — for numeric calculations.
• Assignment: = and augmented assignments like +=, -=, *= — to store values in variables.
• Relational (comparison): ==, !=, >, <, >=, <= — compare values and return True/False.
• Logical: and, or, not — combine boolean conditions.
• Bitwise: &, |, ^, ~, <<, >> — operate at binary bit level (useful for low-level tasks and flags).
• Membership: in, not in — test membership in sequences (strings, lists, tuples, sets, dict keys).
• Identity: is, is not — test if two references point to the same object.

Expressions and evaluation

• Simple expression: a + b * c. Python evaluates based on operator precedence (multiplication before addition) and associativity (left-to-right for most binary operators).
• Parentheses () override precedence: (a + b) * c.
• Type conversion: when operands have different numeric types, Python performs implicit conversion (e.g., int to float). You can also use explicit conversion functions like int(), float(), str().
• Short-circuit evaluation: in logical expressions, Python stops evaluating as soon as the result is determined (e.g., False and expr2 never evaluates expr2).

Important: Operator precedence (high to low) — common subset

1.  ( )        parentheses
2.  **         exponentiation (right-associative)
3.  +x, -x, ~x unary plus, minus, bitwise NOT
4.  *, /, //, %
5.  +, -      addition, subtraction
6.  <<, >>    bit shifts
7.  &, ^, |   bitwise AND, XOR, OR
8.  ==, !=, >, <, >=, <=    comparisons
9.  not      logical NOT
10. and      logical AND
11. or       logical OR
12. if-else (ternary)
13. =, +=, -=, ...  assignment

Best practices

• Use parentheses to make expressions readable and avoid ambiguity.
• Prefer augmented assignment for clarity and performance when updating variables (x += 1).
• Be careful with floating point division vs integer division (use // when integer result is required).
• Use descriptive variable names so expressions read like meaningful statements.

Small code examples (conceptual)

# arithmetic
bill = price * quantity
total = bill + bill * tax_rate

# comparison and logical
eligible = (age >= 18) and (has_id == True)

# membership
if name in students:  # True if name appears in list
    print("Present")

# augmented assignment
x = 5
x *= 3  # x becomes 15

# bitwise for permissions (example)
READ = 0b100
WRITE = 0b010
EXECUTE = 0b001
perm = READ | WRITE  # combine permissions

Summary: Operators let you perform computations and tests; expressions combine operators and operands to produce values. Understanding precedence, associativity, and type behavior is essential to write correct Python programs.

What is control flow? Control flow determines the order in which individual statements, instructions or function calls are executed or evaluated in a program. Conditional statements let a program make decisions and execute different code paths depending on whether a condition is true or false.

Why use conditional statements? To respond to different inputs and situations, implement branching logic (choose one of several actions), validate data, and control program behavior based on computed conditions.

Types of conditional statements in Python

• if: execute a block when a condition is true.
• if-else: choose between two blocks (true vs false).
• if-elif-else: select among multiple exclusive alternatives.
• Nested if: place an if (or if-else) inside another to test sub-conditions.

Basic syntax and examples

if condition:
    # statements when condition is True
elif another_condition:
    # statements when another_condition is True
else:
    # statements when all above conditions are False

Simple Python examples

# if example
age = 17
if age >= 18:
    print('You can vote.')

# if-else example
marks = 45
if marks >= 50:
    print('Pass')
else:
    print('Fail')

# if-elif-else example (grading)
score = 78
if score >= 90:
    grade = 'A'
elif score >= 75:
    grade = 'B'
elif score >= 60:
    grade = 'C'
else:
    grade = 'D'
print('Grade =', grade)

# ternary (conditional) expression
result = 'Even' if n % 2 == 0 else 'Odd'

Boolean expressions and truthiness

• Conditions are expressions that evaluate to True or False.
• Comparisons: ==, !=, <, <=, >, >=.
• Logical operators: and, or, not.
• In Python many values have truthiness: 0, 0.0, '', None and empty containers are False; most other values are True.

Short-circuit evaluation: in expressions with and/or, evaluation stops as soon as the outcome is determined (so later parts may not be evaluated).

Common pitfalls and best practices

• Indentation is mandatory; use consistent indentation (4 spaces recommended).
• Avoid deep nesting; prefer early returns or logical combinations.
• Use elif for multiple mutually exclusive choices rather than many nested if-else.
• Use meaningful boolean variable names to improve readability.

Flow of a conditional (summary)

Evaluate condition → if True execute block A → else (or elif) execute alternative block(s). Each condition is checked in order for if-elif-else chains.

Loops are control-flow structures that repeat a block of code while a condition holds or for each item in a sequence. They help avoid code repetition, process collections, and implement iterative algorithms. Python provides two main loop constructs: while and for.

1. while loop
The while loop repeatedly executes a block as long as a Boolean condition is True. Typical pattern:

while condition:
    statements
    (update to move toward terminating condition)

Care must be taken to update variables used in the condition, otherwise an infinite loop will occur.

2. for loop
Python's for loop iterates over items of any iterable (lists, tuples, strings, range, etc.). Typical pattern:

for item in iterable:
    statements

Commonly used with range(start, stop, step) to generate sequences of integers.

3. Loop control statements
- break: exit the current loop immediately.
- continue: skip the rest of the loop body and start next iteration.
- pass: no-operation placeholder (useful where syntax requires a statement).
- else with loops: an optional else block runs if the loop completes normally (i.e., not terminated by break).

4. Nested loops
Loops may be placed inside other loops. The total number of iterations is typically the product of the iteration counts of each nested level (useful but can increase time complexity).

5. Practical tips
- Use enumerate() when you need both index and item in a for loop.
- Prefer for when iterating known collections/ranges; use while for condition-driven repetition.
- Avoid modifying the iterable you're iterating over (e.g., removing items from a list while using for on it); iterate over a copy instead.

6. Example snippets

# while: sum numbers until user enters 0
n = int(input())
s = 0
while n != 0:
    s += n
    n = int(input())
print(s)

# for with range: print first 5 squares
for i in range(1, 6):
    print(i*i)

# break and else
for x in [2, 3, 5, 7]:
    if x % 2 == 0:
        print('Found even')
        break
else:
    print('No break, all odd primes here (except 2)')

7. Complexity
Loops often determine time complexity. A single loop over n items is O(n). Nested loops that each run n times are O(n^2). Keep this in mind for performance-sensitive code.

What is a function? A function is a named, reusable block of code that performs a specific task. In Python a function helps you break a program into smaller, manageable pieces, improves readability and enables reuse.

Basic syntax:

def function_name(parameter1, parameter2, ...):
    """Optional docstring describing the function"""
    statements
    return value  # optional

Key concepts:

• Definition vs Call: You define a function with def and you call it by writing its name with arguments.
• Parameters and arguments: Parameters are names in the definition; arguments are actual values passed when calling.
• Return value: A function can return a value using return. If omitted, it returns None.
• Parameter types: positional, keyword, default, arbitrary positional (*args), arbitrary keyword (**kwargs).
• Lambda (anonymous) functions: Short single-expression functions: lambda x: x * 2.
• Scope: Variables declared inside a function are local; variables outside are global. Use global or nonlocal only when needed.
• Docstrings and annotations: Add documentation and optional type hints for clarity.

Why use functions? Modularity, reusability, easier testing and debugging, clearer structure and separation of concerns. Functions let you implement algorithms once and call them wherever needed.

Example flow:

# Define
def average(marks):
    return sum(marks) / len(marks)

# Use (call)
avg = average([75, 82, 90])
print(avg)

Best practices:

• Give meaningful function names (verb or verb phrase).
• Keep functions short and focused on one task.
• Write docstrings that explain inputs, outputs and side effects.
• Prefer returning values instead of modifying global state.

What is a parameter? A parameter is a name listed in a function definition. An argument is the actual value passed to the function when it is called. Functions can accept different kinds of parameters to make them flexible and reusable.

Common parameter types in Python:

• Positional (required) parameters: Values must be supplied in the correct order when calling the function.
  Example signature: def add(a, b):
• Default parameters: Have a default value used when the caller omits that argument.
  Example signature: def greet(name, msg='Hello'):
• Keyword arguments: Caller names the parameter when passing a value; order can change.
  Call example: greet(msg='Hi', name='Riya')
• Variable-length positional arguments (*args): Collect extra positional arguments into a tuple.
  Example signature: def total(*numbers):
• Variable-length keyword arguments (**kwargs): Collect extra keyword arguments into a dictionary.
  Example signature: def info(**details):

Parameter order rules (practical guidance): required (positional) parameters first, then default parameters, then *args, then keyword-only parameters (if used), and finally **kwargs. Also, you cannot place a non-default parameter after a default parameter.

Passing behaviour (mutability): Python uses a model often described as "pass-by-object-reference". Mutable objects (like lists, dictionaries) can be changed inside a function and those changes are visible to the caller. Immutable objects (like integers, strings, tuples) cannot be altered in place — reassigning a parameter name inside the function does not change the caller's variable.

Important caveat about default parameters: Default parameter values are evaluated once at function definition time. Using a mutable object (like a list) as a default can lead to unexpected shared state between calls. Use None and create a new object inside the function if needed.

Small code examples:

# positional and default
def power(base, exponent=2):
    return base ** exponent

# variable-length
def summarize(*values):
    return sum(values)

# keyword arguments
def student(name, **marks):
    return name, marks

# mutable default pitfall (avoid this)
def append_bad(item, lst=[]):
    lst.append(item)
    return lst

# safe version
def append_safe(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

Why this matters in real life: Function parameter types let you design flexible APIs: optional settings with defaults, accept any number of data inputs, or capture named configuration options. Understanding mutability prevents bugs when collecting results across multiple calls.

Anonymous Functions (lambda)

Anonymous functions are small one-line functions defined without a name using the lambda keyword. They are used for short operations where writing a full def function is unnecessary.

Syntax: lambda arguments: expression

Characteristics:

• Single expression only (the expression's value is returned).
• Often used with functions like map(), filter(), sorted(), and reduce().
• Useful for short throwaway functions, key functions in sorting, or functional-style programming.

Example usage (HTML code block):

# square using lambda
square = lambda x: x * x
print(square(5))  # Output: 25

# using with map to square a list
nums = [1, 2, 3, 4]
squares = list(map(lambda x: x*x, nums))  # [1, 4, 9, 16]

Common higher-order uses

• map(function, iterable) — apply function to each item.
• filter(function, iterable) — keep items where function(item) is True.
• sorted(iterable, key=function) — sort using function(item) as key.
• functools.reduce(function, iterable) — accumulate values using function.

Recursion

Recursion is a technique where a function calls itself to solve smaller instances of the same problem. Each recursive function must have:

• Base case: a condition that stops further recursion.
• Recursive case: the part where the function calls itself with a smaller/simpler input.

Recursion uses the call stack: each call is pushed onto the stack until the base case is reached, then calls return in reverse order.

Example: factorial n! (= 1×2×...×n)

def factorial(n):
    if n == 0 or n == 1:   # base case
        return 1
    else:
        return n * factorial(n-1)  # recursive call

print(factorial(5))  # Output: 120

Example: Fibonacci sequence (simple recursive form)

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

print(fib(6))  # Output: 8

Important points

• Always ensure a correct base case to avoid infinite recursion (which leads to RecursionError in Python).
• Python has a recursion depth limit (default ~1000). It can be changed with sys.setrecursionlimit() but raising it carelessly can cause stack overflow.
• Recursive solutions can be elegant and easy to reason about for divide-and-conquer problems (e.g., tree traversal, quicksort), but sometimes iterative solutions are more efficient.
• Memoization (caching results) can turn exponential recursive algorithms (like naive Fibonacci) into linear-time algorithms.
• Python does not optimize tail recursion, so tail-recursive styles do not get automatic stack savings.

Comparison & complexity (intuition)

• Linear recursion (one recursive call per call), e.g., factorial or summing a list: time O(n), space O(n) due to stack.
• Binary recursion (two calls per call), e.g., naive Fibonacci: time O(2^n) (exponential), space O(n) (stack depth = n).

Real-life analogies

• Recursive: Like nested dolls — to open the biggest doll you open the next smaller one and repeat until the smallest; then you close them in reverse order. Each doll corresponds to a call on the stack.
• Anonymous function: A sticky note with a short instruction used once and thrown away — quick and temporary.

Practical tips for students

• Use lambda for short, simple functions (single expression) — not for complex logic.
• When recursion is natural (trees, divide-and-conquer), write clear base cases and test small inputs first.
• If recursion is too slow (like Fibonacci), consider memoization or iterative solutions.

What is a string? A string is an ordered sequence of characters enclosed in quotes, e.g. 'Hello', "Welcome". In Python a string is an immutable sequence type used to store text.

Creation: Use single ('...'), double ("..."), or triple quotes ('''...''' or """...""") for multi-line text.

Key properties

• Immutable: Once created, characters in a string cannot be changed. Operations that seem to modify a string actually create a new string.
• Indexed & ordered: Characters have positions starting from 0. Negative indices count from the end: -1 is the last character.

Core operations

• Indexing: s[i] returns the character at index i (0-based). Example: s[0] is the first char.
• Slicing: s[start:stop:step] extracts a substring from index start to stop-1, stepping by step. Omitting start or stop uses defaults (start=0, stop=len(s)).
• Concatenation: s1 + s2 joins two strings.
• Repetition: s * n repeats s n times.
• Membership: 'sub' in s returns True if substring 'sub' occurs in s.
• Length: len(s) returns number of characters.

Common string methods (short list)

• Case: s.lower(), s.upper(), s.capitalize(), s.title()
• Whitespace: s.strip(), s.lstrip(), s.rstrip()
• Search & replace: s.find('sub'), s.index('sub'), s.count('sub'), s.replace('old', 'new')
• Split & join: s.split(sep) -> list of parts; sep.join(list) -> string
• Checks: s.isalpha(), s.isdigit(), s.isalnum(), s.startswith(prefix), s.endswith(suffix)

Formatting: Build strings with placeholders: old style: 'Hello %s' % name; str.format(): 'Hi {0}'.format(name); f-strings (Python 3.6+): f'Hi {name}'.

Escapes & raw strings: Use backslash escapes for special chars: '\n' newline, '\t' tab, '\\' backslash. Prefix with r to make raw string (r'C:\path') so backslashes are literal.

Why immutability matters: Because strings are immutable, operations produce new objects. For many small concatenations use list-join pattern for efficiency: ''.join(parts).

Examples in one line: s = 'Hello'; s[1] -> 'e'; s[1:4] -> 'ell'; 'ab' * 3 -> 'ababab'; 'py' in 'python' -> True.

Common pitfalls: IndexError for out-of-range indexing, using replace without assigning result (s.replace(...) returns new string), confusing str.index (throws ValueError if not found) vs str.find (returns -1).

What is a string? A string is an ordered sequence of characters enclosed in quotes (single, double or triple) used to represent text. Example: 'Hello', "World".

Immutability: Strings are immutable — once created their contents cannot be changed. Operations that seem to modify a string actually create a new string.

Indexing and slicing: Characters in a string are accessed using indices. First character index = 0, last = -1. Slicing extracts substrings using the notation s[start:stop:step] (stop is exclusive).

s = 'python'
# indexing
s[0]        # 'p'
s[-1]       # 'n'
# slicing
s[1:4]      # 'yth'
s[::2]      # 'pto'

Basic operations: concatenation (+), repetition (*), membership (in), length (len(s)), iteration (for char in s).

Common string methods (categories):

• Case conversion: lower(), upper(), title(), capitalize(), swapcase()
• Trimming/padding: strip(), lstrip(), rstrip(), zfill(), rjust(), ljust(), center()
• Search & replace: find(), index(), rfind(), count(), replace()
• Split & join: split(), rsplit(), splitlines(), join()
• Tests: isalpha(), isdigit(), isalnum(), isspace(), islower(), isupper()
• Formatting helpers: format(), f-strings, old-style % operator

Formatting strings (why): Formatting is used to produce readable text, align columns, show numeric precision (currency, percentages), build templates and reports.

Three common formatting styles:

1. Old-style: 'Name: %s Age: %d' % (name, age)
2. str.format(): 'Name: {:10} Score: {:.2f}'.format(name, score)
3. f-strings (recommended in Python 3.6+): f'Name: {name:10} Score: {score:.2f}'

Format mini-language (summary): an expression like {:[fill][align][width][,][.precision][type]} controls output. Examples:

• {:10} — minimum width 10 (right by default)
• {:<10}, {:^10}, {:>10} — left, center, right alignment
• {:0>5} — pad with zeros to width 5
• {:.2f} — floating point with 2 decimals
• {:,} — include thousand separators (e.g., 1,000)
• {:b}, {:x}, {:o} — binary, hex, octal formatting

Practical notes:

• Use strip() to remove extra spaces from user input before validation.
• Use split() and join() to parse or build CSV/text lines.
• Use formatting to align reports or print tables in console applications.

Small example (receipt line):

item = 'Notebook'
price = 79.5
print(f'{item:20} {price:8.2f}')
# Notebook             79.50

These methods and formatting capabilities form the backbone of text processing in Python and are heavily used in data cleaning, reporting, user interfaces and file I/O.

What is a list? A list in Python is an ordered sequence of items (elements) enclosed in square brackets []. Lists can store items of different types (heterogeneous), are indexed (starting at 0), and are mutable (you can change their elements after creation). Lists can also be nested (a list can contain other lists).

Key characteristics:

• Ordered: position of each element is fixed unless you change the list.
• Indexed: elements accessed by integer indices (0, 1, 2, ...).
• Mutable: individual elements can be modified, added, or removed.
• Heterogeneous: elements may be of different data types (numbers, strings, objects).
• Dynamic size: length grows or shrinks at runtime.

Creating lists: l = [1, 2, 3] or l = list(). You can create an empty list and then add items.

Indexing and negative indices: Access elements with l[0], l[1], etc. Negative indices count from the end: l[-1] is the last element, l[-2] the second last.

Slicing: Get a sub-list using l[start:stop] (start included, stop excluded). General form: l[start:stop:step]. Examples: l[1:4], l[:3], l[::2].

Common sequence operations (basic operators and built-in functions): + (concatenate two lists), * (repeat), in (membership test), len(l) (length), min(l), max(l) (for comparable items), and sorted(l) (returns a sorted copy).

Important list methods (mutating operations):

• l.append(x) — add x at end.
• l.extend(iterable) — append all elements from iterable.
• l.insert(i, x) — insert x at index i.
• l.remove(x) — remove first occurrence of x.
• l.pop() or l.pop(i) — remove and return last or i-th element.
• del l[i] — delete element at index i; del l[a:b] deletes a slice.
• l.clear() — remove all elements.
• l.index(x) — return index of first x (error if not found).
• l.count(x) — number of occurrences of x.
• l.sort() — sort list in place; sorted(l) returns a sorted copy.
• l.reverse() — reverse elements in place.
• l.copy() — shallow copy of the list.

Mutability and aliasing: Assigning b = a does not copy; both names refer to same list. Use b = a.copy() (shallow) or import copy; copy.deepcopy(a) for independent nested copies.

Nested lists: Represent matrices or tables. Example: m = [[1,2,3],[4,5,6]]. Access element row r, column c by m[r][c].

Iteration: Use for item in l: to traverse elements. List comprehensions provide concise creation: [x*x for x in range(5)].

Performance notes (important to remember): indexing is O(1). Appending is amortized O(1). Inserting or removing in middle, searching, or concatenating large lists are O(n) operations (n = list length). Slicing makes a new list (cost proportional to slice length).

CBSE tip: Understand examples by writing small programs that create, modify, and print lists — test append vs extend, and observe how negative indexing and slicing work.

What is a tuple?
A tuple is an ordered, immutable collection of items in Python. Tuples store a fixed sequence of values which can be of different data types (int, float, string, another tuple, etc.). Because they are immutable, once created their elements cannot be changed, added or removed.

How to create tuples

# empty tuple
t0 = ()
# tuple with elements
t1 = (1, 2, 3)
# parentheses are optional in many contexts (comma defines tuple)
t2 = 4, 5, 6
# single-element tuple requires a trailing comma
t3 = (7,)
# nested tuple
t4 = (1, (2, 3), 'a')

Key properties

• Ordered: elements have fixed positions (indexes start at 0).
• Immutable: cannot change elements after creation (no append/pop/insert).
• Heterogeneous: can contain mixed data types.
• Hashable if all elements are hashable: can be used as dictionary keys or set elements.

Common operations

# indexing and negative indexing
a = (10, 20, 30)
print(a[0])    # 10
print(a[-1])   # 30

# slicing
print(a[0:2])  # (10, 20)

# concatenation and repetition
b = (40, 50)
print(a + b)   # (10, 20, 30, 40, 50)
print(a * 2)   # (10, 20, 30, 10, 20, 30)

# membership, length, methods
print(20 in a)        # True
print(len(a))         # 3
print(a.count(20))    # number of occurrences
print(a.index(30))    # index of first occurrence

# packing and unpacking
coord = (5, 6)
x, y = coord

Why use tuples (advantages)

• Immutability makes data safer (no accidental changes).
• Tuples can be used as keys in dictionaries when needed.
• Often slightly faster and more memory-efficient than lists for fixed data.

Class 11 tips
Remember the single-element tuple syntax (x,) and that parentheses can be omitted in many contexts when commas separate values. Use tuples when you need an ordered collection that should not change (for example, coordinates, fixed records, constant configurations).

What is a dictionary? A dictionary in Python is an unordered (in older versions), mutable collection of key-value pairs. Each value is accessed using a unique key. Dictionaries are implemented as hash tables, providing very fast lookup, insertion and deletion on average.

Basic properties

• Syntax: a dictionary literal uses curly braces: {key1: value1, key2: value2}.
• Keys must be immutable and hashable (e.g., numbers, strings, tuples). Values can be any object (including lists or other dictionaries).
• Mutable: you can add, update or remove items after creation.
• From Python 3.7 onward, dictionaries preserve insertion order.

Creating dictionaries

# literal
d = {'apple': 3, 'banana': 5}

# from pairs using dict()
pairs = [('a', 1), ('b', 2)]
d2 = dict(pairs)

# fromkeys
keys = ['x','y','z']
d3 = dict.fromkeys(keys, 0)

# comprehension
squares = {n: n*n for n in range(1,6)}

Accessing and modifying

value = d['apple']         # access (KeyError if missing)
value = d.get('apple', 0)   # safe access with default

# add/update
d['orange'] = 7

# remove
d.pop('banana')             # remove by key
last = d.popitem()          # remove and return arbitrary pair (LIFO in 3.7+)

Common methods

• keys(), values(), items() — iterate over keys, values, or key-value tuples.
• update(other_dict) — merge another dict (overwrites duplicates).
• clear() — remove all items; copy() — shallow copy.
• setdefault(key, default) — return value if key exists, otherwise set it to default and return default.

Iteration patterns

for k in d:             # iterates keys
    print(k, d[k])

for k, v in d.items():   # iterates key-value pairs
    print(k, v)

Nested dictionaries are dictionaries that contain other dictionaries as values. Useful to represent structured data (e.g., student -> {name, age, marks}).

When to use a dictionary? Use dictionaries when you need fast lookup by a unique key (e.g., mapping IDs to records, frequency counts, configuration settings). For ordered indexed sequences use lists; for simple key-value pairs where keys are ordered and frequently sliced, consider pandas or OrderedDict (legacy).

Notes: because dictionaries are mutable, avoid using them as keys in other dicts or sets. Keys must be hashable. For copying nested structures, use copy.deepcopy to avoid shared references.

What it is
Type conversions between collections in Python means converting data from one collection type to another — for example, from a list to a set, tuple to list, or from a list of pairs to a dictionary. Conversions are done using constructors and helper methods so you can use the strengths of each collection type (mutability, uniqueness, ordering, mapping).

Why and when to convert

• To remove duplicates: convert a list to a set.
• To make sequence immutable: convert list to tuple.
• To get index access: convert set to list or tuple.
• To build key->value mappings: convert a list of (key, value) pairs to a dict.
• To iterate keys/values: convert dict to list (of keys), list(dict.values()), or list(dict.items()).

Common conversion functions and rules

• list(iterable) → creates a mutable sequence. Example: list('abc') → ['a','b','c'].
• tuple(iterable) → creates an immutable sequence.
• set(iterable) → creates an unordered collection of unique, hashable elements (duplicates removed).
• dict(mapping_or_seq_of_pairs) → creates a mapping. Passing a sequence of (key, value) pairs builds a dict.
• dict.keys(), dict.values(), dict.items() return view objects; wrap with list(...) or tuple(...) to convert to a sequence.

Important behavior and edge-cases

• Converting a list to a set removes duplicates but does not preserve order. If you need to remove duplicates while preserving original order, use list(dict.fromkeys(my_list)) or an OrderedDict approach.
• Sets and dict keys require hashable elements. You cannot create a set of lists (lists are unhashable), but you can create a set of tuples.
• Converting a dict to a list directly (i.e. list(my_dict)) returns a list of keys.
• Order: dict preserves insertion order (Python 3.7+), set is unordered; converting between them may change order.

Short code examples

# list -> set (remove duplicates)
my_list = [1, 2, 2, 3]
my_set = set(my_list)   # {1, 2, 3}

# set -> list (indexable)
ordered_list = list(my_set)  # order may vary

# list -> tuple (make immutable)
my_tuple = tuple(my_list)    # (1, 2, 2, 3)

# tuple -> list (modify elements)
new_list = list(my_tuple)

# list of pairs -> dict
pairs = [('roll1', 85), ('roll2', 90)]
marks = dict(pairs)   # {'roll1': 85, 'roll2': 90}

# dict -> list of keys / values / items
keys = list(marks)            # ['roll1', 'roll2']
values = list(marks.values()) # [85, 90]
items = list(marks.items())   # [('roll1', 85), ('roll2', 90)]

# remove duplicates while keeping order
uniq_ordered = list(dict.fromkeys([3,1,3,2]))  # [3, 1, 2]

Overview: In Python, built-in functions are ready-to-use functions provided by the language (no import required). The standard library is a collection of modules bundled with Python that provide additional functionality (math, random, datetime, os, json, statistics, etc.). Together they let you solve many common tasks quickly, reliably and with fewer lines of code.

Built-in functions (what and why):

• Examples: print(), input(), len(), int(), float(), str(), type(), sum(), min(), max(), sorted(), abs(), round(), range(), pow(), divmod().
• Called directly: len(my_list) or abs(-5). They live in the global/built-in namespace.
• Use when you need common, well-tested operations (conversion, aggregation, introspection, I/O).

Standard library (modules):

• Import syntax: import module, from module import name, import module as alias.
• Common modules and purpose:
  • math — mathematical functions: sqrt, factorial, sin, cos, log
  • random — pseudo-random numbers: random(), randint(), choice(), shuffle()
  • datetime — dates and times
  • statistics — mean, median, mode, stdev
  • json, csv — data interchange
  • os, sys — operating system and interpreter interaction

How they differ:

• Built-in functions are always available without import.
• Standard-library functions live inside modules and require import.
• Both are part of the Python ecosystem, tested and optimized—prefer them over writing low-level code.

Namespaces and calling: When you do import math, call math.sqrt(9). If you do from math import sqrt, call sqrt(9) directly. Use aliases for convenience: import numpy as np (third-party).

Benefits: Reliability, readability, less code, portability. Using library functions reduces bugs and improves performance.

Small code examples:

# built-in
nums = [2, 5, 1]
print(len(nums), sum(nums), max(nums))

# standard library
import math
print(math.sqrt(25), math.factorial(4))

import random
print(random.randint(1, 10))

from datetime import date
print(date.today())

Teaching tips: Show direct calls to built-ins, then show import and use of modules. Ask students to replace manual code (e.g., computing average via loop) with statistics.mean() to highlight advantages.

What is File Handling?
File handling means creating, opening, reading, writing, updating and closing files from a program so that data can be stored permanently. In Python, file handling is done using the built-in open() function which returns a file object. Files may be text or binary.

Basic operations

• Open: f = open(filename, mode, encoding=...). The mode decides whether you read, write or append. Common modes: 'r' (read), 'w' (write, truncates), 'a' (append), 'x' (create), 'b' (binary), '+' (update read/write).
• Read: f.read() (all), f.readline() (one line), f.readlines() (list of lines). Use an integer argument to limit bytes/characters: f.read(10).
• Write: f.write(string) writes a string to the file; f.writelines(list_of_strings) writes multiple lines (no automatic newlines).
• Move file pointer: f.tell() gives current position; f.seek(offset, whence) moves pointer. whence can be 0 (start), 1 (current), 2 (end).
• Close: f.close() frees resources. Prefer with open(...) as f: to auto-close even on errors.

Important behaviours

• Opening in 'w' truncates (clears) existing file. Use 'a' to preserve content and add at the end.
• Binary mode 'b' reads/writes bytes; text mode decodes/encodes using encoding (default UTF-8 in many cases).
• Use exception handling (try/except) or a with block to handle errors such as FileNotFoundError or IOError.

Why it matters (real-life uses): saving student marks, logging application activities, reading configuration, processing CSV/JSON data, storing uploaded files, etc.

Short example (read and write)

# Write
with open('students.txt', 'w', encoding='utf-8') as f:
    f.write('Alice,85\nBob,78\n')

# Read
with open('students.txt', 'r', encoding='utf-8') as f:
    data = f.read()
    print(data)

Best practices

• Use with to auto-close files.
• Specify encoding when reading/writing text to avoid platform differences.
• Use appropriate mode: 'r' for reading, 'a' for appending logs, 'b' when handling images or other binary files.

Overview
In programming, an error is a problem in code that prevents correct execution. An exception is a runtime event indicating an error or unusual condition that can be caught and handled. Debugging is the process of finding and fixing errors or logical mistakes.

Types of Errors

• Syntax Errors — mistakes in the program's grammar (e.g., missing colon, unmatched parenthesis). Caught before running the program.
• Runtime Errors / Exceptions — occur during program execution (e.g., division by zero, file not found). These produce an exception and a stack trace.
• Logical Errors — the program runs but gives incorrect results (e.g., wrong formula or wrong loop condition). Hardest to detect.

Exceptions in Python

Python has built-in exception types (ValueError, TypeError, IndexError, KeyError, ZeroDivisionError, FileNotFoundError, etc.). Exceptions form a hierarchy under BaseException → Exception. When an exception occurs, Python creates an exception object and prints a traceback showing the call stack.

Handling Exceptions

Use try / except to catch exceptions and handle them gracefully. Optionally use else to run code when no exception occurs and finally for cleanup that must run in all cases.

try:
    result = a / b
except ZeroDivisionError:
    print("Cannot divide by zero")
else:
    print("Result:", result)
finally:
    print("Cleanup code runs always")

Raising and Custom Exceptions

You can raise an exception intentionally using raise, and define custom exceptions by subclassing Exception:

if age < 0:
    raise ValueError("Age cannot be negative")

class MyError(Exception):
    pass

Debugging Techniques

• Use print/logging statements to inspect variable values and control flow.
• Use an interactive debugger (IDE or pdb) to set breakpoints, step through code, and inspect the call stack.
• Read tracebacks carefully — they give the file, line number, and exception message.
• Write small test cases (unit tests) and validate expected outputs.
• Use assertions (assert condition, "msg") to document and check assumptions during development.
• Keep functions small and modular so bugs are easier to isolate.

Best Practices

• Catch specific exceptions, not a bare except:, so you don't hide bugs.
• Log exceptions with stack traces for later analysis (use the logging module).
• Clean up resources (files, network connections) in finally or use context managers (with).
• Validate input early to prevent exceptions (e.g., check for zero before dividing).

Example trace (short): Traceback (most recent call last): File "main.py", line 10, in <module> result = a/b ZeroDivisionError: division by zero — shows where the error occurred and its type.

Overview: Program design and problem solving is a systematic process of converting a real-world problem into a working computer program. It emphasizes understanding the problem, devising an algorithm, representing it (pseudocode/flowchart), implementing in code (Python), and testing/debugging.

Key steps

• Understand the problem — identify inputs, expected outputs, constraints, and edge cases.
• Analyze — break the problem into smaller subproblems; decide data types and possible algorithms.
• Design — create algorithm using stepwise refinement; write pseudocode and draw flowchart. Choose control structures (sequence, selection, iteration) and data structures (list, tuple, dictionary).
• Implement — convert pseudocode into Python code, organize code into functions (modular design) for clarity and reuse.
• Test and debug — use sample inputs (including edge cases), trace outputs, fix logic/syntax/runtime errors, use print/debugger and assertions.
• Optimize and document — improve readability and efficiency, add comments and user instructions.

Design strategies & principles

• Top-down design (decompose into modules) and bottom-up (build reusable components).
• Stepwise refinement: iteratively refine a high-level step into detailed steps.
• Use of functions to encapsulate tasks; single-responsibility principle for each function.
• Handle errors and edge cases explicitly (input validation).

Pseudocode and flowcharts: Pseudocode uses plain-language structured steps (no syntax). Flowcharts use symbols (oval = start/end, parallelogram = input/output, rectangle = process, diamond = decision). Both help verify logic before coding.

Algorithm types & control structures: Sequential (straight steps), Selection (if/if-else/elif), Iteration (for, while). Common patterns: linear search, binary search (on sorted data), sorting (bubble, selection, insertion), accumulation (summing), and counting.

Correctness & complexity: Verify correctness by reasoning and testing. Consider time complexity (how running time grows with input size) and space complexity (extra memory used). Aim for clear, correct solutions first; then optimize if needed.