Computational Thinking and Programming - II

Main Idea

Computational Thinking and Programming–II develops systematic Python problem-solving through variables, data types, operators, control statements, strings, collections, functions, recursion, file handling, data structures, and exception handling. These features support modular, maintainable programs that process data appropriately and respond safely to runtime errors.

Key Concepts and Definitions

• Python Revision: Review of Python syntax, variables, data types, operators, input and output, conditional statements, loops, strings, and built-in functions.
• Function: A named, reusable block of code designed to perform a specific task.
• Parameter: A variable listed in a function definition that receives a value when the function is called.
• Argument: The actual value supplied to a function when it is called.
• Return Statement: A statement that sends a result from a function back to the calling code.
• Scope: The part of a program where a variable can be accessed; local variables belong to a function, while global variables are accessible more widely.
• Recursion: A programming technique in which a function calls itself to solve smaller versions of the same problem.
• Base Case: The condition that stops recursive calls and prevents infinite recursion.
• Recursive Case: The part of a recursive function that calls the function again with a smaller or simpler input.
• Text File: A file that stores data as readable characters, commonly using extensions such as .txt or .csv.
• Binary File: A file that stores data in binary form and is commonly handled using Python’s pickle module.
• File Mode: The purpose for which a file is opened, such as read ('r'), write ('w'), append ('a'), or read-write ('r+').
• File Pointer: The current position in a file from which reading or writing takes place.
• List: An ordered, mutable collection that can contain duplicate values and elements of different data types.
• Tuple: An ordered, immutable collection that can contain duplicate values.
• Dictionary: A mutable collection of key-value pairs in which each key is unique.
• Stack: A linear data structure that follows the Last In, First Out principle; list methods append() and pop() can implement it.
• Queue: A linear data structure that follows the First In, First Out principle; it can be implemented using lists or collections.deque.
• Exception: An error that occurs during program execution and interrupts the normal flow of instructions.
• Exception Handling: The process of managing runtime errors using try, except, else, and finally blocks.
• try Block: The block containing statements that may produce an exception.
• except Block: The block that executes when a specified exception occurs.
• else Block: An optional block that executes only when no exception occurs in the try block.
• finally Block: An optional block that executes whether or not an exception occurs, commonly used for cleanup operations.

Supporting Arguments and Evidence

• Functions support modular program design. A function is defined using def, as in:

   def add(a, b):
       return a + b
   

Functions divide programs into meaningful, reusable blocks, improving readability, testing, reuse, and maintenance. They may accept positional, keyword, default, or variable-length arguments. If a function does not explicitly use return, it returns None.

• Parameters, arguments, return values, and scope determine how functions exchange data. A parameter is specified in the function definition, whereas an argument is supplied when the function is called. A return statement passes a result back to the calling code. Local variables are created inside a function and normally cannot be accessed outside it, while global variables have wider accessibility.

• Recursion solves problems through progressively smaller instances. Every recursive function must contain a base case and a recursive case. The base case stops further calls, while the recursive case calls the function again with a smaller or simpler input. For factorial, the relationship is:

$$n!=n\times (n-1)!\text{for }n>0,$$ with: $$0!=1.$$ Recursion is appropriate when a problem naturally consists of smaller versions of itself, but each call must progress toward the base case.

• File handling provides permanent data storage. The function open(filename, mode) opens a file. Common modes include 'r' for reading, 'w' for writing, 'a' for appending, and 'b' for binary mode. Opening a file in 'w' mode creates a new file or replaces existing contents, whereas 'a' mode adds data at the end. Using:

   with open(...) as file:
   

automatically closes the file when the block finishes, reducing the risk of data loss, corruption, or resource wastage.

• Text-file operations support different forms of reading and writing. Common text-file methods include read(), readline(), readlines(), write(), writelines(), seek(), and tell(). The file pointer records the current position from which reading or writing occurs. CSV files store tabular data in rows and separated fields; Python’s csv module provides reader and writer tools.

• Binary files store data in binary form, including Python objects. Python’s pickle.dump() can store Python objects in a binary file, while pickle.load() retrieves them. Binary files are therefore distinct from readable text files and require appropriate binary handling.

• The choice of data structure should reflect the required operation. Lists are mutable ordered collections and support indexing, slicing, append(), extend(), insert(), remove(), pop(), sort(), and reverse(). Tuples are ordered but immutable. Dictionaries provide key-based lookup; their keys must be unique and hashable, while values may be repeated and may have different types.

• Stacks and queues implement different processing orders. A stack follows Last In, First Out: the usual push operation is implemented with append(), and removal is implemented with pop(). A queue follows First In, First Out: enqueue adds an item at the rear, while dequeue removes an item from the front. Queues can be implemented using lists or collections.deque.

• Operators determine how values are processed. The expression 5 / 2 produces 2.5, whereas 5 // 2 produces 2. The % operator gives the remainder, and ** performs exponentiation. Correct use of operators is part of the broader Python revision of syntax, variables, data types, input and output, conditions, loops, strings, and built-in functions.

• Exception handling manages runtime problems without unnecessarily concealing errors. Common exceptions include ZeroDivisionError, ValueError, TypeError, IndexError, KeyError, FileNotFoundError, and NameError. The try block contains statements that may fail; except handles specified exceptions; else runs only when no exception occurs; and finally runs regardless of whether an exception occurs, often for cleanup. Specific exception handlers are clearer and safer than a general handler. Syntax errors occur before execution, whereas runtime exceptions occur during execution.

• Reliable programs anticipate input and operational problems. Good programming practice includes validating input, using descriptive names, avoiding unnecessary repetition, and separating data processing from user interaction. Exception handling should respond suitably to likely runtime problems without hiding underlying programming mistakes.

What to Remember

Functions provide modularity, recursion requires both a base case and a recursive case, and data structures should be selected according to their operations: lists for ordered mutable data, dictionaries for key-based lookup, stacks for LIFO processing, and queues for FIFO processing. Files require suitable modes and proper closing, while exception handling uses try, except, else, and finally to manage runtime errors safely.