Computational Thinking and Programming - I

Main Idea

Computational thinking provides a systematic method for solving problems by decomposing them, identifying patterns, selecting relevant details, designing algorithms, and expressing solutions clearly. Python implements these solutions through variables, data types, operators, expressions, statements, control-flow structures, and collections such as strings, lists, tuples, and dictionaries.

Key Concepts and Definitions

• Algorithm: A finite, ordered set of clear steps used to solve a problem.
• Computational Thinking: A problem-solving approach based on decomposition, pattern recognition, abstraction, and algorithm design.
• Python: A high-level, interpreted, general-purpose programming language known for readable syntax.
• Token: The smallest meaningful unit in a Python program, such as a keyword, identifier, literal, operator, or delimiter.
• Identifier: A name used for variables, functions, or other program elements; it may contain letters, digits, and underscores but cannot begin with a digit or be a keyword.
• Keyword: A reserved word with a predefined meaning in Python, such as if, else, for, while, and True.
• Variable: A named reference used to store or access a value during program execution.
• Data Type: A classification that identifies the kind of value stored, such as int, float, bool, str, list, tuple, or dict.
• Literal: A value written directly in a program, such as 25, 3.14, True, or 'Hello'.
• Expression: A combination of values, variables, operators, and function calls that produces a result.
• Statement: An instruction that performs an action, such as assignment, input, output, conditional execution, or looping.
• Operator: A symbol or word that performs an operation on one or more operands.
• Arithmetic Operators: Operators used for numerical calculations, including +, -, , /, //, %, and *.
• Relational Operators: Operators used to compare values: <, <=, >, >=, ==, and !=; they return True or False.
• Logical Operators: and, or, and not combine or reverse Boolean conditions.
• Assignment: The process of assigning a value to a variable using = or a compound assignment operator such as +=.
• Input and Output: input() accepts data from the user as a string, while print() displays data or messages.
• Type Conversion: Changing a value from one data type to another using functions such as int(), float(), str(), and bool().
• Conditional Statement: A statement that selects actions based on conditions, using if, elif, and else.
• Iteration: Repeated execution of a block of code using a loop such as for or while.
• for Loop: A loop that visits each item in a sequence or range.
• while Loop: A loop that repeats while its condition remains True.
• break: A control statement that immediately terminates the nearest loop.
• continue: A control statement that skips the remaining statements in the current loop iteration and starts the next iteration.
• String: An immutable sequence of characters enclosed in single, double, or triple quotes.
• String Indexing: Accessing an individual character using a position, beginning at index 0 from the left or -1 from the right.
• String Slicing: Extracting part of a string using the form sequence[start:stop:step], where stop is excluded.
• List: An ordered, mutable collection that can contain values of different data types and allows duplicate elements.
• Tuple: An ordered, immutable collection that can contain values of different data types and allows duplicate elements.
• Dictionary: A mutable collection of key-value pairs in which keys are unique and used to access corresponding values.
• Mutability: The ability of an object to be changed after it is created; lists and dictionaries are mutable, while strings and tuples are immutable.
• Function: A reusable block of code that performs a particular task; built-in functions include len(), type(), and range().
• Indentation: Leading whitespace used in Python to define blocks of code, such as the body of a loop or conditional.
• Syntax Error: An error caused by breaking the grammatical rules of Python.
• Runtime Error: An error that occurs while a syntactically correct program is running.
• Logical Error: An error in the program’s reasoning that produces incorrect output without necessarily stopping execution.

Supporting Arguments and Evidence

• A programming solution should begin with understanding the problem, identifying its inputs and outputs, designing an algorithm, and translating that algorithm into Python. Computational thinking supports this process through decomposition into smaller subproblems, abstraction of important details, and pattern recognition of reusable solutions.

• Python uses indentation rather than braces to group statements into blocks, so consistent indentation is essential. Assignment follows the form variable = expression, and Python determines the variable’s type at runtime.

• Python’s basic built-in data types include int for integers, float for decimal numbers, bool for True or False, str for text, and the collection types list, tuple, and dict.

• Arithmetic expressions use +, -, *, /, //, %, and . The / operator returns a floating-point result, // performs floor division, % returns the remainder, and performs exponentiation. Operator precedence generally follows parentheses, exponentiation, multiplication/division/floor division/modulus, addition/subtraction, comparison operators, not, and, and then or. Parentheses can clarify evaluation.

• Expressions calculate values, whereas statements control actions and execution order. Relational operators return Boolean results, and the Boolean values are True and False. Logical expressions use and, or, and not to combine or reverse conditions.

• input() returns a string, so numeric input must be converted explicitly. For example:

   age = int(input('Enter age: '))
   

The print() function displays one or more values and supports arguments such as sep for separation and end for line termination.

• Conditional statements select actions. An if statement executes a block when its condition is True; elif tests additional conditions; and else executes when no preceding condition is True.

• A for loop is appropriate for sequence-based repetition and commonly uses range(start, stop, step). The stop value is excluded; for example, range(5) produces 0, 1, 2, 3, and 4. A while loop repeats while its condition remains True, but its controlling condition must be updated to avoid an infinite loop. The statements break and continue respectively terminate the nearest loop or skip to the next iteration.

• Strings, lists, and tuples support indexing, slicing, concatenation using +, repetition using *, membership testing using in, and length calculation using len(). String indexing begins at 0 for the first character, while negative indexing begins at -1 for the last character. Slicing uses sequence[start:stop:step], with the stop position excluded.

• Strings and tuples are immutable, so their individual elements cannot be changed directly after creation. Lists are mutable and support methods including append(), extend(), insert(), remove(), pop(), sort(), and reverse(). A one-element tuple requires a trailing comma, as in (7,); parentheses alone do not create a tuple.

• Dictionaries use braces containing key-value pairs, for example:

   {'name': 'Riya', 'age': 16}
   

Keys must be unique and generally hashable, while values may repeat. Values are accessed using dictionary[key]. Common methods include keys(), values(), items(), get(), update(), and pop(). The membership operator in checks whether an item occurs in a sequence or whether a key occurs in a dictionary.

• Data-structure choice affects storage, modification, and access. Strings are suited to text, lists to changeable ordered data, tuples to fixed ordered data, and dictionaries to key-based lookup.

• Clear naming, meaningful decomposition, comments, proper indentation, and modular design improve readability, debugging, and maintenance. Comments begin with # and are ignored during execution, but they document the program and improve its readability.

• A good program should be correct, readable, modular, efficient, and tested with normal, boundary, and invalid inputs. A trace table records variable values and condition results step by step when manually checking a program.

• Syntax, runtime, and logical errors must be distinguished. A syntax error violates Python’s grammatical rules; a runtime error occurs while a syntactically correct program is running; and a logical error produces incorrect output without necessarily stopping execution. Therefore, a program that runs without a syntax error may still contain runtime or logical errors.

What to Remember

Computational thinking develops step-by-step solutions, while Python provides the expressions, control flow, and data structures needed to implement them. Revise the distinctions among conditionals, for loops, and while loops; among strings, lists, tuples, and dictionaries; and among syntax, runtime, and logical errors. For examinations, remember Python’s indentation rules, operator behaviour, zero-based indexing, tuple immutability, dictionary key-value access, and the need to test normal, boundary, and invalid inputs.