# Computer Programming and Python Fundamentals ### **1. Programming Basics** ##### **1.1 Definition of Programming** Programming is the process of creating instructions that a computer can understand and execute to perform specific tasks. These instructions are written in a programming language, which is a way for humans to communicate with computers. - **Key Characteristics of Python**: - **High-level language**: Python abstracts away complex hardware-level details, making it easier to read and write. - **Interpreted**: Python code is executed line by line, making it interactive and easy to debug. - **Dynamically typed**: Variables in Python don’t need a declared type; the interpreter determines the type at runtime. ##### **1.2 Types of Programming Languages** 1. **Low-Level Languages**: - Directly interact with hardware. - Example: Assembly language, Machine code. - Harder to read and write, but extremely efficient. - **Example of Assembly code**: ```assembly MOV AX, BX ; Move the value from BX to AX ``` 2. **High-Level Languages**: - Easier for humans to understand. - Examples: Python, Java, C++. - These languages are more abstract and typically involve a compiler or interpreter to run the code. 3. **Interpreted vs. Compiled Languages**: - **Interpreted Languages**: - Execute code line by line. - Examples: Python, JavaScript. - Useful for quick testing and debugging. - **Compiled Languages**: - Convert the entire code into machine language before execution. - Examples: C, C++. - Generally faster at runtime because the conversion happens in advance. ##### **1.3 Python Execution Models** Python code can be executed in two primary ways: 1. **Interactive Mode**: - Allows you to test Python code interactively in a terminal or shell. - Use the command `python` or `python3` to enter the Python REPL (Read-Eval-Print Loop). - Example: ```python >>> print("Hello, World!") Hello, World! ``` 2. **Script Mode**: - Used to write more extensive and reusable Python programs in `.py` files. - Run a Python script by typing `python script_name.py` in the terminal. - Example: ```python #my_script.py print("Hello from a script!") ``` ##### **1.4 Code Structure in Python** 1. **Statements**: - A statement is a single instruction that the Python interpreter can execute. - Example: ```python x = 5 # Assignment statement print(x) # Print statement ``` 2. **Blocks**: - A block is a group of statements that are executed together. - Python uses **indentation** to define blocks (4 spaces is the standard). - Example: ```python if x > 0: print("x is positive") # This is part of the block print("Block ends here") ``` 3. **Indentation**: - Indentation is mandatory in Python and defines the structure of the program. - Example: ```python if x > 0: print("Positive number") # Indented block ``` ### **2. Python Syntax and Semantics** ##### **2.1 Comments** Comments are used to explain the code and are ignored by the Python interpreter. They help make the code more understandable for others (or yourself in the future). 1. **Single-line Comments**: - Start with a `#` symbol. - Example: ```python #This is a single-line comment print("Comments are ignored by the interpreter") ``` 2. **Multi-line Comments**: - Enclosed in triple quotes (`"""` or `'''`). - Example: ```python """ This is a multi-line comment. It spans multiple lines. """ print("Multi-line comments are also ignored") ``` ##### **2.2 Keywords** - **Definition**: Keywords are reserved words in Python that have a special meaning and cannot be used as variable names. - Examples of Keywords: `if`, `else`, `while`, `for`, `class`, `def`, `return`, etc. - To see the full list of keywords: ```python help("keywords") ``` ##### **2.3 Identifiers** - **Definition**: Identifiers are names used to identify variables, functions, or objects in Python. - **Rules for Identifiers**: 1. Must start with a letter (A-Z, a-z) or an underscore `_`. 2. Can contain letters, digits (0-9), and underscores. 3. Cannot be the same as a keyword. 4. Case-sensitive: `Name` and `name` are different identifiers. - Examples: ```python my_variable = 10 # Valid _hidden_variable = 20 # Valid 1variable = 30 # Invalid ``` ##### **2.4 Whitespace Sensitivity** - Python uses whitespace (indentation) to define code blocks. - Incorrect indentation raises an `IndentationError`. - Example: ```python #Correct indentation if x > 0: print("Positive") #Incorrect indentation if x > 0: print("Positive") # This will raise an IndentationError ``` ### **3. Data Types and Variables** ##### **3.1 Variables** 1. **Definition**: Variables are used to store data values. 2. **Declaration and Initialization**: - Python does not require explicit variable declarations. - Example: ```python x = 10 # Integer name = "Alice" # String ``` ##### **3.2 Basic Data Types** 1. **`int` (Integer)**: - Whole numbers (e.g., `42`, `-5`). 2. **`float` (Floating-point)**: - Decimal numbers (e.g., `3.14`, `-0.5`). 3. **`str` (String)**: - A sequence of characters (e.g., `"Hello"`, `'World'`). 4. **`bool` (Boolean)**: - Logical values: `True` or `False`. ##### **3.3 Dynamic Typing** - Python is a **dynamically typed language**, meaning that you do not need to specify the data type of a variable when declaring it. The interpreter determines the type based on the assigned value. - Variables in Python can change their type during execution. **Example**: ```python x = 10 # Initially, x is an integer print(type(x)) # Output: x = "Now a string" # x is reassigned to a string print(type(x)) # Output: ``` ##### **3.4 Type Conversion** Type conversion is the process of converting one data type into another. 1. **Implicit Conversion**: - Python automatically converts a smaller data type to a larger data type (e.g., `int` to `float`) when required. - **Example**: ```python x = 3 y = 2.5 result = x + y # x is implicitly converted to float print(result) # Output: 5.5 print(type(result)) # Output: ``` 2. **Explicit Conversion**: - You can manually convert data types using built-in functions like `int()`, `float()`, and `str()`. - **Example**: ```python #Convert string to integer x = int("42") print(x) # Output: 42 #Convert integer to string y = str(123) print(y) # Output: "123" print(type(y)) # Output: ``` 3. **Common Conversion Functions**: - `int()`: Converts a value to an integer. - `float()`: Converts a value to a float. - `str()`: Converts a value to a string. - `bool()`: Converts a value to a Boolean. ### **4. Operators** Operators are symbols or keywords used to perform operations on variables or values. Python provides several categories of operators. ##### **4.1 Arithmetic Operators** Arithmetic operators are used for mathematical calculations. | Operator | Description | Example | Output | | -------- | ------------------- | -------- | ------ | | `+` | Addition | `5 + 3` | `8` | | `-` | Subtraction | `5 - 3` | `2` | | `*` | Multiplication | `5 * 3` | `15` | | `/` | Division | `5 / 2` | `2.5` | | `//` | Floor Division | `5 // 2` | `2` | | `%` | Modulus (remainder) | `5 % 2` | `1` | | `**` | Exponentiation | `2 ** 3` | `8` | **Examples**: ```python a = 10 b = 3 print(a + b) # Output: 13 print(a % b) # Output: 1 print(a ** b) # Output: 1000 ``` ##### **4.2 Comparison Operators** Comparison operators compare two values and return a Boolean result (`True` or `False`). | Operator | Description | Example | Output | | -------- | ------------------------ | -------- | ------ | | `==` | Equal to | `5 == 5` | `True` | | `!=` | Not equal to | `5 != 3` | `True` | | `<` | Less than | `3 < 5` | `True` | | `>` | Greater than | `5 > 3` | `True` | | `<=` | Less than or equal to | `3 <= 3` | `True` | | `>=` | Greater than or equal to | `5 >= 3` | `True` | **Example**: ```python x = 10 y = 20 print(x < y) # Output: True print(x == y) # Output: False ``` ##### **4.3 Logical Operators** Logical operators are used to combine conditional statements. | Operator | Description | Example | Output | | -------- | ------------------------------------------------ | --------------------- | ------- | | `and` | Returns `True` if both conditions are true | `(5 > 3) and (3 > 1)` | `True` | | `or` | Returns `True` if at least one condition is true | `(5 > 3) or (3 < 1)` | `True` | | `not` | Reverses the Boolean result | `not(5 > 3)` | `False` | **Example**: ```python x = 5 print(x > 3 and x < 10) # Output: True print(x > 3 or x < 4) # Output: True print(not(x > 3)) # Output: False ``` ##### **4.4 Assignment Operators** Assignment operators are used to assign values to variables. | Operator | Description | Example | Equivalent To | | -------- | ------------------- | -------- | ------------- | | `=` | Assign | `x = 5` | | | `+=` | Add and assign | `x += 3` | `x = x + 3` | | `-=` | Subtract and assign | `x -= 3` | `x = x - 3` | | `*=` | Multiply and assign | `x *= 3` | `x = x * 3` | | `/=` | Divide and assign | `x /= 3` | `x = x / 3` | **Example**: ```python x = 10 x += 5 print(x) # Output: 15 x *= 2 print(x) # Output: 30 ``` ##### **4.5 Bitwise Operators** Bitwise operators perform operations on binary representations of numbers. | Operator | Description | Example | Output | | -------- | ----------- | -------- | ------ | | `&` | AND | `5 & 3` | `1` | | ` | ` | OR | `5 | | `^` | XOR | `5 ^ 3` | `6` | | `~` | NOT | `~5` | `-6` | | `<<` | Left shift | `5 << 1` | `10` | | `>>` | Right shift | `5 >> 1` | `2` | **Example**: ```python x = 5 # Binary: 0101 y = 3 # Binary: 0011 print(x & y) # Output: 1 (Binary: 0001) print(x | y) # Output: 7 (Binary: 0111) ``` ### **5. Input and Output** ##### **5.1 Input** - The `input()` function is used to get input from the user as a string. - Example: ```python name = input("Enter your name: ") print("Hello, " + name) ``` ##### **5.2 Output** - The `print()` function displays information to the console. - Example: ```python age = 25 print(f"I am {age} years old.") # Output: I am 25 years old. ``` --- # Control Flow - Conditional Blocks and Loops ### **1. Conditional Statements** Conditional statements allow your program to make decisions based on certain conditions. This is achieved using the `if`, `if-else`, and `if-elif-else` constructs. ##### **1.1 If Statement** The `if` statement is the simplest form of a conditional. It checks a condition and executes the code block only if the condition is `True`. **Syntax**: ```python if condition: # code block (executed if condition is True) ``` **Example**: ```python x = 10 if x > 5: print("x is greater than 5") ``` **Explanation**: - The condition `x > 5` is evaluated. - If the condition is `True`, the indented code block will run. **More Examples**: ```python #Check if a number is positive number = 7 if number > 0: print("The number is positive") ``` ##### **1.2 If-Else Statement** The `if-else` statement provides an alternative block of code to execute if the condition is `False`. **Syntax**: ```python if condition: # code block (executed if condition is True) else: # alternative code block (executed if condition is False) ``` **Example**: ```python x = 3 if x > 5: print("x is greater than 5") else: print("x is 5 or less") ``` **Explanation**: - If `x > 5` evaluates to `True`, the first block runs. - If `x > 5` evaluates to `False`, the `else` block runs. **More Examples**: ```python #Check if a number is even or odd number = 4 if number % 2 == 0: print("The number is even") else: print("The number is odd") ``` ##### **1.3 If-Elif-Else Statement** When there are multiple conditions to check, use `if-elif-else`. It allows you to test several conditions in order, executing the first block with a `True` condition. **Syntax**: ```python if condition1: # code block (executed if condition1 is True) elif condition2: # code block (executed if condition1 is False and condition2 is True) else: # alternative code block (executed if all conditions are False) ``` **Example**: ```python x = 10 if x > 15: print("x is greater than 15") elif x > 5: print("x is greater than 5 but not greater than 15") else: print("x is 5 or less") ``` **Explanation**: - The program checks each condition in sequence. - If a condition is `True`, its block runs, and the rest are skipped. **More Examples**: ```python #Grading system based on score score = 85 if score >= 90: print("Grade: A") elif score >= 80: print("Grade: B") elif score >= 70: print("Grade: C") else: print("Grade: F") ``` ##### **1.4 Nested Conditions** Conditions can be nested inside each other to check multiple levels of logic. **Syntax**: ```python if condition1: if condition2: # nested block (executed if condition1 and condition2 are True) ``` **Example**: ```python x = 10 if x > 5: if x % 2 == 0: print("x is greater than 5 and even") ``` **Explanation**: - First, `x > 5` is checked. - If `True`, the nested condition `x % 2 == 0` is checked. **More Examples**: ```python #Check if a number is positive and even number = 12 if number > 0: if number % 2 == 0: print("The number is positive and even") else: print("The number is positive but odd") else: print("The number is not positive") ``` ### **2. Loops** Loops allow you to repeat a block of code multiple times. Python supports two types of loops: `for` and `while`. ##### **2.1 For Loop** The `for` loop iterates over a sequence (like a list, string, or range). **Syntax**: ```python for item in sequence: # code block (executed for each item in the sequence) ``` **Example**: ```python fruits = ["apple", "banana", "cherry"] for fruit in fruits: print(fruit) ``` **Explanation**: - The loop goes through each item in the sequence (`fruits`). - On each iteration, the variable `fruit` holds the current item. **More Examples**: ```python #Print numbers from 0 to 4 for i in range(5): # range(5) generates 0, 1, 2, 3, 4 print(i) ``` ##### **2.2 While Loop** The `while` loop repeats a block of code as long as the condition is `True`. **Syntax**: ```python while condition: # code block (executed while condition is True) ``` **Example**: ```python x = 0 while x < 5: print(x) x += 1 # Increment x to avoid an infinite loop ``` **Explanation**: - The loop checks the condition `x < 5`. - If `True`, the block runs, and `x` is incremented. - The loop stops when `x < 5` becomes `False`. **More Examples**: ```python #Print numbers until the user enters "stop" while True: user_input = input("Enter a number (or 'stop' to quit): ") if user_input == "stop": break print(f"You entered: {user_input}") ``` ### **3. Loop Control Statements** Control statements modify the flow of loops. ##### **3.1 Break** The `break` statement exits the nearest enclosing loop immediately. **Example**: ```python for i in range(10): if i == 5: break # Exit the loop when i equals 5 print(i) ``` **Output**: ``` 0 1 2 3 4 ``` ##### **3.2 Continue** The `continue` statement skips the rest of the code in the current iteration and moves to the next iteration. **Example**: ```python for i in range(5): if i == 3: continue # Skip the iteration when i equals 3 print(i) ``` **Output**: ``` 0 1 2 4 ``` ##### **3.3 Else in Loops** The `else` block in a loop runs if the loop is not terminated by a `break`. **Example**: ```python for i in range(3): print(i) else: print("Loop completed!") ``` **Output**: ``` 0 1 2 Loop completed! ``` **Example with `break`**: ```python for i in range(3): if i == 2: break print(i) else: print("Loop completed!") # This won't execute ``` **Output**: ``` 0 1 ``` --- # Data Collections - Tuples, Dictionaries, Lists, and Strings ### **1. Lists** Lists are one of the most versatile and commonly used data structures in Python. They allow you to store multiple items in a single variable. ##### **1.1 Definition** - A **list** is: - **Ordered**: Items have a specific sequence. - **Mutable**: Items can be changed after the list is created. - **Heterogeneous**: Items can be of different data types. - **Syntax**: Lists are defined using square brackets `[]`. **Example**: ```python #A list of fruits fruits = ["apple", "banana", "cherry"] #A mixed-type list mixed_list = [42, "hello", 3.14] ``` ##### **1.2 Basic Operations** 1. **Creating a List**: ```python fruits = ["apple", "banana", "cherry"] ``` 2. **Accessing Items**: - Access by index (starts at `0` for the first item). - Negative indices start from the end (`-1` for the last item). ```python print(fruits[0]) # Output: apple print(fruits[-1]) # Output: cherry ``` 3. **Modifying Items**: - Lists are mutable, so you can modify items using their index. ```python fruits[1] = "orange" print(fruits) # Output: ['apple', 'orange', 'cherry'] ``` ##### **1.3 List Methods** 1. **Appending Items**: - Add an item to the end of the list. ```python fruits.append("grape") print(fruits) # Output: ['apple', 'orange', 'cherry', 'grape'] ``` 2. **Inserting Items**: - Insert an item at a specific index. ```python fruits.insert(1, "kiwi") print(fruits) # Output: ['apple', 'kiwi', 'orange', 'cherry', 'grape'] ``` 3. **Removing Items**: - Remove by value: ```python fruits.remove("orange") print(fruits) # Output: ['apple', 'kiwi', 'cherry', 'grape'] ``` - Remove by index: ```python fruits.pop(0) # Removes 'apple' print(fruits) # Output: ['kiwi', 'cherry', 'grape'] ``` 4. **Sorting Items**: - Alphabetically or numerically. ```python fruits.sort() print(fruits) # Output: ['cherry', 'grape', 'kiwi'] ``` 5. **Reversing Items**: - Reverse the order of items. ```python fruits.reverse() print(fruits) # Output: ['kiwi', 'grape', 'cherry'] ``` ##### **1.4 Slicing** - Extract a sublist using indices. - Syntax: `list[start:end]` (start inclusive, end exclusive). ```python sublist = fruits[1:3] print(sublist) # Output: ['grape', 'cherry'] ``` ##### **1.5 Iterating** - Use a `for` loop to iterate through items. ```python for fruit in fruits: print(fruit) ``` **Output**: ``` kiwi grape cherry ``` ### **2. Tuples** Tuples are similar to lists but immutable, meaning their contents cannot be changed after creation. ##### **2.1 Definition** - A **tuple** is: - **Ordered**: Items have a specific sequence. - **Immutable**: Cannot modify items once created. - **Heterogeneous**: Can contain different data types. - **Syntax**: Tuples are defined using parentheses `()`. **Example**: ```python coordinates = (10, 20) ``` ##### **2.2 Basic Operations** 1. **Creating a Tuple**: ```python numbers = (1, 2, 3) ``` 2. **Accessing Items**: - Similar to lists, use indices. ```python print(coordinates[0]) # Output: 10 ``` ##### **2.3 Immutability** - Tuples cannot be modified. - Attempting to do so raises an error. ```python coordinates[0] = 15 # TypeError: 'tuple' object does not support item assignment ``` ##### **2.4 Common Use Cases** 1. **Returning Multiple Values**: - Functions can return multiple values as a tuple. ```python def get_coordinates(): return (10, 20) x, y = get_coordinates() print(x, y) # Output: 10 20 ``` 2. **Using Tuples as Keys**: - Tuples are hashable and can be used as dictionary keys (unlike lists). ### **3. Dictionaries** Dictionaries are collections of key-value pairs, where each key is unique. ##### **3.1 Definition** - A **dictionary**: - **Unordered**: Items do not maintain a fixed order (Python 3.7+ maintains insertion order). - **Mutable**: Can add, modify, or delete key-value pairs. - **Keys** must be immutable (e.g., strings, numbers, or tuples). - **Syntax**: Defined using curly braces `{}`. **Example**: ```python person = {"name": "Alice", "age": 25} ``` ##### **3.2 Basic Operations** 1. **Creating a Dictionary**: ```python person = {"name": "Alice", "age": 25} ``` 2. **Accessing Values**: - Use the key to retrieve the corresponding value. ```python print(person["name"]) # Output: Alice ``` 3. **Adding or Updating Items**: - Add a new key-value pair or update an existing one. ```python person["city"] = "New York" print(person) # Output: {'name': 'Alice', 'age': 25, 'city': 'New York'} ``` 4. **Deleting Items**: - Remove a key-value pair using `del`. ```python del person["age"] print(person) # Output: {'name': 'Alice', 'city': 'New York'} ``` ##### **3.3 Dictionary Methods** 1. **`keys()`**: - Get all keys in the dictionary. ```python print(person.keys()) # Output: dict_keys(['name', 'city']) ``` 2. **`values()`**: - Get all values. ```python print(person.values()) # Output: dict_values(['Alice', 'New York']) ``` 3. **`items()`**: - Get all key-value pairs. ```python print(person.items()) # Output: dict_items([('name', 'Alice'), ('city', 'New York')]) ``` ### **4. Strings** Strings are sequences of characters enclosed in quotes. ##### **4.1 Definition** - A **string**: - **Immutable**: Cannot be changed after creation. - Defined using single `'` or double `"` quotes. **Example**: ```python text = "Hello, world!" ``` ##### **4.2 Basic Operations** 1. **Accessing Characters**: ```python print(text[0]) # Output: H print(text[-1]) # Output: ! ``` 2. **Slicing**: ```python substring = text[0:5] print(substring) # Output: Hello ``` ##### **4.3 Common String Methods** 1. **`upper()`**: Convert to uppercase. ```python print("hello".upper()) # Output: HELLO ``` 2. **`lower()`**: Convert to lowercase. ```python print("HELLO".lower()) # Output: hello ``` 3. **`strip()`**: Remove leading and trailing whitespace. ```python print(" hello ".strip()) # Output: hello ``` 4. **`split()`**: Split the string into a list. ```python print("a,b,c".split(",")) # Output: ['a', 'b', 'c'] ``` 5. **`join()`**: Join a list of strings into one string. ```python print(",".join(["a", "b", "c"])) # Output: a,b,c ``` ##### **4.4 String Formatting** **Using f-strings**: ```python name = "Alice" age = 25 print(f"My name is {name} and I am {age} years old.") ``` **Output**: ``` My name is Alice and I am 25 years old. ``` --- # Functions and Exceptions ### **1. Functions** Functions are one of the most fundamental building blocks in Python programming. They allow you to organize your code into reusable, modular pieces that perform specific tasks. ##### **1.1 Definition** - A **function** is: - A reusable block of code that performs a specific task. - Used to improve code organization and reduce redundancy. - **Key Characteristics**: - **Input**: Functions can take arguments (inputs) to customize their behavior. - **Output**: Functions can return a value as the result of their operations. - **Reusable**: Functions can be called multiple times in different parts of the program. ##### **1.2 Creating Functions** To create a function in Python, use the `def` keyword followed by the function name and parentheses `()`. **Syntax**: ```python def function_name(parameters): # code block return value ``` **Example**: ```python #Function to greet a user def greet(name): return f"Hello, {name}!" #Calling the function print(greet("Alice")) # Output: Hello, Alice! ``` ##### **1.3 Calling Functions** Functions are executed when you "call" them by their name followed by parentheses `()`. **Example**: ```python #Define the function def greet(name): return f"Hello, {name}!" #Call the function print(greet("Bob")) # Output: Hello, Bob ``` ##### **1.4 Parameters and Arguments** Functions can accept data, known as parameters, which are passed to the function when it is called. 1. **Positional Arguments**: - These are matched to the function's parameters based on their position. ```python def add(a, b): return a + b print(add(2, 3)) # Output: 5 ``` 2. **Keyword Arguments**: - Arguments can be specified by name, making their order irrelevant. ```python def greet(name, greeting="Hello"): return f"{greeting}, {name}!" print(greet(name="Alice", greeting="Hi")) # Output: Hi, Alice! print(greet(name="Bob")) # Output: Hello, Bob ``` ##### **1.5 Variable-Length Arguments** Python allows functions to accept an arbitrary number of arguments using `*args` (for positional arguments) and `**kwargs` (for keyword arguments). 1. **`*args`**: - Used to handle variable-length positional arguments. ```python def add(*numbers): return sum(numbers) print(add(1, 2, 3, 4)) # Output: 10 print(add(5, 10)) # Output: 15 ``` 2. **`**kwargs`**: - Used to handle variable-length keyword arguments. ```python def greet(**info): return f"Hello, {info['name']}!" print(greet(name="Alice", age=30)) # Output: Hello, Alice! ``` ##### **1.6 Return Values** Functions can return a result using the `return` statement. **Example**: ```python def square(number): return number ** 2 result = square(4) print(result) # Output: 16 ``` **Explanation**: - The function `square` takes a number, computes its square, and returns the result. ##### **1.7 Default Parameters** Default parameters allow you to define default values for function arguments. If a value is not provided when calling the function, the default value is used. **Syntax**: ```python def function_name(parameter=default_value): # code block ``` **Example**: ```python def greet(name, greeting="Hello"): return f"{greeting}, {name}!" print(greet("Alice")) # Output: Hello, Alice! print(greet("Alice", "Hi")) # Output: Hi, Alice! ``` **Explanation**: - The `greeting` parameter has a default value of `"Hello"`. - If no value is passed for `greeting`, it defaults to `"Hello"`. ##### **1.8 Functions Without a Return Statement** Functions that do not explicitly return a value will return `None` by default. **Example**: ```python def say_hello(): print("Hello!") result = say_hello() print(result) # Output: None ``` **Explanation**: - The function `say_hello()` only prints a message but does not return any value. ##### **1.9 Anonymous Functions (Lambda Functions)** Lambda functions are small, anonymous functions defined using the `lambda` keyword. They are often used for short, simple operations. **Syntax**: ```python lambda arguments: expression ``` **Example**: ```python #A lambda function to calculate the square of a number square = lambda x: x ** 2 print(square(5)) # Output: 25 #Using lambda in a map function numbers = [1, 2, 3, 4] squares = map(lambda x: x ** 2, numbers) print(list(squares)) # Output: [1, 4, 9, 16] ``` ##### **1.10 Nested Functions** Functions can be defined inside other functions. These are called nested functions or inner functions. **Example**: ```python def outer_function(outer_value): def inner_function(inner_value): return outer_value + inner_value return inner_function add_five = outer_function(5) print(add_five(10)) # Output: 15 ``` **Explanation**: - `inner_function` is defined inside `outer_function`. - `outer_function` returns `inner_function`, which remembers the value of `outer_value`. ##### **1.11 Higher-Order Functions** A higher-order function is a function that takes another function as an argument or returns a function as a result. **Examples**: 1. **Using a Function as an Argument**: ```python def apply_function(func, value): return func(value) print(apply_function(lambda x: x ** 2, 5)) # Output: 25 ``` 2. **Returning a Function**: ```python def multiplier(factor): return lambda x: x * factor double = multiplier(2) print(double(5)) # Output: 10 ``` ### **2. Exceptions** An exception is an error that occurs during the execution of a program. Python provides tools to detect and handle these errors gracefully. ##### **2.1 Definition** - **Exceptions**: - Errors that disrupt the normal flow of a program. - Examples: Division by zero, invalid type conversions, accessing unavailable resources. - If not handled, exceptions cause the program to terminate. ##### **2.2 Handling Exceptions** You can handle exceptions using the `try-except` block. **Syntax**: ```python try: # Code that may raise an exception except ExceptionType: # Code to handle the exception ``` **Example**: ```python try: x = int(input("Enter a number: ")) print(f"You entered {x}") except ValueError: print("Invalid input! Please enter a valid number.") ``` **Explanation**: - The code inside the `try` block is executed. - If a `ValueError` occurs (e.g., entering a non-numeric value), the `except` block is executed. ##### **2.3 Finally Block** The `finally` block is used to execute code regardless of whether an exception occurred or not. It is commonly used for cleanup operations, such as closing a file or releasing resources. **Syntax**: ```python try: # Code that may raise an exception except ExceptionType: # Handle the exception finally: # Code that always executes ``` **Example**: ```python try: file = open("data.txt", "r") content = file.read() except FileNotFoundError: print("File not found!") finally: print("Closing the file (if open).") file.close() ``` **Explanation**: - The `finally` block ensures the file is closed even if an exception occurs. ##### **2.4 Raising Exceptions** You can raise exceptions manually using the `raise` keyword. **Syntax**: ```python raise ExceptionType("Error message") ``` **Example**: ```python def validate_age(age): if age < 18: raise ValueError("Age must be 18 or older.") return "Valid age" try: print(validate_age(15)) except ValueError as e: print(e) # Output: Age must be 18 or older. ``` ##### **2.5 Catching Multiple Exceptions** You can handle multiple types of exceptions in a single `try-except` block by specifying a tuple of exception types. **Example**: ```python try: value = int(input("Enter a number: ")) result = 10 / value except (ValueError, ZeroDivisionError) as e: print(f"Error: {e}") ``` **Explanation**: - If a `ValueError` or `ZeroDivisionError` occurs, the corresponding error message is printed. ##### **2.6 Handling All Exceptions** To catch all exceptions, use a bare `except` clause. However, this is generally discouraged as it may hide unexpected issues. **Example**: ```python try: result = 10 / 0 except Exception as e: print(f"An error occurred: {e}") ``` **Explanation**: - The `except Exception` clause catches any exception and prints the error message. ##### **2.7 Custom Exceptions** You can define your own exception classes by inheriting from the built-in `Exception` class. **Example**: ```python class CustomError(Exception): def __init__(self, message): self.message = message def validate_age(age): if age < 18: raise CustomError("Age must be 18 or older.") return "Valid age" try: print(validate_age(15)) except CustomError as e: print(e.message) # Output: Age must be 18 or older. ``` **Explanation**: - `CustomError` is a user-defined exception. - It is raised using the `raise` keyword when the condition is not met. ##### **2.8 Else in Try-Except** An `else` block can be added after `except`. It runs if no exceptions are raised. **Example**: ```python try: value = int(input("Enter a number: ")) except ValueError: print("Invalid input!") else: print(f"Valid number: {value}") ``` **Explanation**: - If no `ValueError` occurs, the `else` block runs. ##### **2.9 Suppressing Exceptions** The `contextlib.suppress` method can be used to suppress specific exceptions. **Example**: ```python from contextlib import suppress with suppress(FileNotFoundError): with open("non_existent_file.txt", "r") as file: content = file.read() ``` **Explanation**: - If the file does not exist, no exception is raised, and the program continues. ##### **2.10 Best Practices for Exception Handling** 1. **Be Specific**: - Catch specific exceptions rather than using a general `except` clause. ```python try: x = int(input("Enter a number: ")) except ValueError: print("Invalid input!") ``` 2. **Avoid Overusing Exceptions**: - Use exceptions for exceptional cases, not for regular control flow. 3. **Clean Up Resources**: - Always clean up resources (e.g., close files) in a `finally` block or use a context manager (`with` statement). 4. **Provide Meaningful Messages**: - Include useful error messages to help users understand the issue. --- # Computer Programming and Python Fundamentals (Additional Content) ### **1. Understanding the Built-in Functions `type()` and `id()`** #### **1.1 `type()` Function** The `type()` function returns the type (class) of a given object. It is often used to verify the data type of a variable, especially in debugging or when handling dynamically typed values. **Syntax**: ```python type(object) ``` **Example**: ```python x = 42 print(type(x)) # Output: ``` This tells you that `x` is of type `int`. #### **1.2 `id()` Function** The `id()` function returns the “identity” of an object. This identity is a unique integer that remains constant for the object during its lifetime. In CPython (the most common Python interpreter), this corresponds to the memory address. **Syntax**: ```python id(object) ``` **Example**: ```python x = 42 print(id(x)) # Output: a unique integer representing the object's memory address ``` Although this output is not meaningful for logic, it helps in understanding how variables reference memory. ### **2. Common Python Error Types** While the PCEP exam does not focus heavily on writing exception handling code, it often includes questions that test your understanding of **error types** resulting from incorrect syntax or operations. #### **2.1 `SyntaxError`** Occurs when the code is not syntactically correct. **Example**: ```python print("Hello" # Missing closing parenthesis → SyntaxError ``` This error happens before the code is even executed. #### **2.2 `TypeError`** Occurs when an operation or function is applied to an object of inappropriate type. **Example**: ```python print("5" + 5) # TypeError: cannot concatenate str and int ``` You cannot add a string and an integer directly. You must explicitly convert one to match the other's type. ```python print("5" + str(5)) # Output: 55 ``` #### **2.3 `NameError`** Occurs when you try to use a variable that hasn’t been defined. ```python print(x) # If x was never assigned before → NameError ``` ### **3. Boolean Conversion Rules in Python** The `bool()` function is used to convert values into Boolean `True` or `False`. Understanding which values evaluate to `False` is essential for writing conditional logic. #### **3.1 Falsy Values** The following values evaluate to `False` when converted using `bool()`: - The number zero: `0`, `0.0` - Empty sequences or collections: `''`, `[]`, `{}`, `()` - The special value `None` **Example**: ```python print(bool("")) # Output: False print(bool([])) # Output: False print(bool(0)) # Output: False print(bool(None)) # Output: False ``` #### **3.2 Truthy Values** Any value not listed above is considered `True` when converted to a Boolean. **Example**: ```python print(bool("hello")) # Output: True print(bool(1)) # Output: True print(bool([1, 2])) # Output: True ``` ### **4. Customizing `print()` with `sep` and `end` Parameters** The `print()` function can be customized using the `sep` and `end` parameters: - **`sep` (separator)**: Defines the string inserted between arguments. - **`end`**: Defines what is printed at the end of the output (default is newline `\n`). #### **Example 1: Using `sep`** ```python print("apple", "banana", "cherry", sep=" | ") #Output: apple | banana | cherry ``` #### **Example 2: Using `end`** ```python print("Hello", end="!!!") print("World") #Output: Hello!!!World ``` #### **Example 3: Both together** ```python print("Hello", "World", sep="--", end="!!!") #Output: Hello--World!!! ``` This is a frequent PCEP test pattern, often used to assess your understanding of Python's flexibility in output formatting. ### Summary | Concept | Function / Use | Example | | ------------------- | ----------------------------------- | ------------------------------------------- | | `type()` | Returns type of object | `type(5)` → `` | | `id()` | Returns unique object ID | `id(x)` | | Error Types | `SyntaxError`, `TypeError` | `print("5" + 5)` → `TypeError` | | `bool()` conversion | Empty = `False`, Non-empty = `True` | `bool("")` → `False`, `bool("Hi")` → `True` | | `print(sep=, end=)` | Output control | `print("A", "B", sep="--", end="!")` | --- # Control Flow - Conditional Blocks and Loops (Additional Content) ### **1. The `else` Clause with a `while` Loop** In Python, the `else` block can be used with both `for` and `while` loops. The `else` clause **executes only if the loop completes normally**, that is, **without hitting a `break` statement**. While many learners see it used with `for` loops, it works the same way with `while` loops. #### **Example: `while` with `else`** ```python x = 0 while x < 3: print(x) x += 1 else: print("While loop completed") ``` **Output**: ``` 0 1 2 While loop completed ``` #### **Explanation**: - The loop runs while `x < 3`. - After `x` reaches 3, the condition becomes false. - Since the loop **was not interrupted by a `break`**, the `else` block runs. #### **With `break` inside the loop**: ```python x = 0 while x < 5: if x == 3: break print(x) x += 1 else: print("This will NOT be printed") ``` **Output**: ``` 0 1 2 ``` In this case, the `else` block is **skipped** because the loop was **terminated with `break`**. ### **2. The `pass` Statement** The `pass` statement in Python is used as a **placeholder**. It does **nothing when executed**, but is syntactically required when a statement is needed, such as in an `if`, `for`, `while`, or function body. #### **Syntax**: ```python if condition: pass # Do nothing ``` #### **Example**: ```python x = 10 if x > 0: pass # Placeholder for future logic print("Program continues...") ``` **Explanation**: - In situations where you're required to have a statement (e.g., after `if`, `for`, etc.) but haven't implemented logic yet, `pass` keeps the code syntactically valid. This is especially common in: - Empty function definitions during development - Class method placeholders - Branches in control flow yet to be implemented **Important for PCEP**: PCEP might include a question with this option to test if you understand that `pass` is valid and does not produce an error. ### **3. `while True` and `break`: Simulating Indefinite Loops** This is a very common pattern in Python to simulate an indefinite loop that continues until a specific condition is met. It often replaces the traditional `do-while` loop found in other languages. #### **Pattern**: ```python while True: user_input = input("Enter something (or 'exit' to quit): ") if user_input == "exit": break print(f"You entered: {user_input}") ``` #### **Explanation**: - `while True` creates an infinite loop. - The loop continues endlessly unless a `break` statement is encountered. - It's useful when the termination condition **depends on user input or runtime behavior**, not something easily written in a `while` condition. ### Summary Table | Feature | Syntax | Purpose | | -------------------- | --------------------------------- | -------------------------------------------------- | | `while ... else` | `while condition: ... else:` | Executes `else` only if the loop is **not broken** | | `pass` | `if x > 0: pass` | Does nothing, used as a **placeholder** | | `while True + break` | `while True: if condition: break` | Infinite loop with manual termination | --- # Data Collections - Tuples, Dictionaries, Lists, and Strings (Additional Content) ### **1. The `in` and `not in` Operators in Lists and Dictionaries** The `in` operator is used to check if a value exists in a collection (e.g., a list or dictionary). `not in` does the opposite. #### **1.1 Usage with Lists** ```python fruits = ["apple", "banana", "cherry"] print("apple" in fruits) # True print("grape" not in fruits) # True ``` - This checks whether `"apple"` is an **element** in the list. #### **1.2 Usage with Dictionaries** ```python person = {"name": "Alice", "age": 25} print("name" in person) # True → checks if "name" is a key print("Alice" in person) # False → values are not searched ``` - When used with a dictionary, `in` only checks the **keys**, not values. #### **PCEP Exam Tip**: You might see a question like: ```python info = {"x": 100} print(100 in info) ``` - Answer: `False`, because `100` is a **value**, not a key. ### **2. The Safer Way to Access Dictionary Values: `get()`** When accessing values in a dictionary, there are **two main methods**: #### **2.1 Direct Indexing** ```python person = {"name": "Alice"} print(person["city"]) # Raises KeyError if "city" is not a key ``` - This causes an error if the key doesn’t exist. #### **2.2 Using `.get()`** ```python print(person.get("city")) # Returns None instead of crashing ``` - `.get()` is safer and avoids a `KeyError`. #### **PCEP Exam Tip**: You may see a question testing which line is safe to run without error. Always consider using `.get()` if the key might be missing. ### **3. Strings Are Iterable** A string in Python is an iterable object, meaning you can loop through its characters just like a list. #### **Example**: ```python for ch in "hi": print(ch) ``` **Output**: ``` h i ``` This is important in the context of `for` loops and demonstrates that strings behave like sequences. ### **4. Understanding Slice Behavior in Strings vs. Lists** Slicing syntax is the same across different sequence types in Python, but the **resulting data type matches the original**. #### **String Example**: ```python text = "abcde" print(text[1:4]) # Output: 'bcd' (still a string) ``` #### **List Example**: ```python lst = ["a", "b", "c", "d", "e"] print(lst[1:4]) # Output: ['b', 'c', 'd'] (still a list) ``` #### **Key Concept**: - The slice returns the **same type** as the original sequence. - Be cautious not to confuse string slices with list slices, especially in multiple-choice questions. ### **5. `{}` Is Not an Empty Set in Python** This is a very **common misconception**. #### **Example**: ```python a = {} # This is an empty dictionary b = set() # This is an empty set ``` - `{}` always creates a dictionary, **even if it's empty**. - To create an empty set, you must use `set()`. #### **Why This Matters**: Using `{}` when you intend to create a set can cause silent logic errors or confusion in type-checking. #### **Verification**: ```python print(type({})) # print(type(set())) # ``` ### Summary Table | Feature | Code Example | Output | Key Takeaway | | ------------------ | -------------------------------- | ---------------- | ---------------------------- | | `in` with list | `"apple" in ["apple", "banana"]` | `True` | Checks list elements | | `in` with dict | `"name" in {"name": "Alice"}` | `True` | Checks keys only | | `.get()` vs `[]` | `dict.get("missing")` | `None` | Safer than `dict["missing"]` | | String is iterable | `for ch in "hi"` | hi | String acts like a sequence | | String slicing | `"abcde"[1:4]` | `'bcd'` | Returns a string | | List slicing | `["a","b","c","d"][1:3]` | `['b','c']` | Returns a list | | Empty dictionary | `{}` | `` | Not a set! | | Empty set | `set()` | `` | Correct syntax | --- # Functions and Exceptions (Additional Content) ### **1. Indentation Is Required for Function Bodies** In Python, **indentation is mandatory**. It is not just for readability—it defines **code blocks** such as function bodies, loops, conditionals, etc. #### **Function Definition Syntax Rule**: ```python def function_name(): # This is the function body print("Hello") # ← Must be indented ``` #### **Common Mistake**: ```python def f(): print("Hi") # SyntaxError: expected an indented block ``` This will cause a `SyntaxError` because Python expects the function body to be **indented consistently**, typically using **4 spaces** per indentation level. #### **Key Point for PCEP**: Questions may include code like the one above and ask whether it will produce an error. If indentation is missing or inconsistent, the answer is likely `SyntaxError`. ### **2. Functions Without `return` Implicitly Return `None`** If a function does **not include a `return` statement**, it implicitly returns `None`. #### **Example**: ```python def f(): pass print(f()) # Output: None ``` Even though `f()` does nothing, Python automatically returns `None`. #### **Type Check**: ```python print(type(f())) # Output: ``` This confirms that the return value is of type `NoneType`, which is the type of the built-in singleton `None`. #### **Why It Matters for PCEP**: You may encounter a question asking what a function returns if it has no `return` statement. Always remember: the default return is `None`. ### **3. Common Exception Types and Their Descriptions** Although the PCEP exam does not require you to write complex exception handling, it **does test your ability to recognize** which types of errors occur in different scenarios. Here is a **quick-reference list** of common Python exceptions you should recognize: | Exception Name | Description | Example | | ------------------- | ----------------------------------------------------------------- | -------------- | | `ValueError` | Raised when a function receives a valid type but an invalid value | `int("abc")` | | `TypeError` | Raised when an operation is performed on incompatible types | `"2" + 1` | | `ZeroDivisionError` | Raised when dividing a number by zero | `10 / 0` | | `IndexError` | Raised when accessing an index that’s out of range in a sequence | `[1, 2][5]` | | `KeyError` | Raised when accessing a dictionary with a key that doesn’t exist | `{"a":1}["b"]` | #### **Example Breakdown**: ```python print(int("abc")) # ValueError print("2" + 1) # TypeError print(10 / 0) # ZeroDivisionError print([1, 2][5]) # IndexError print({"a": 1}["b"]) # KeyError ``` #### **PCEP Exam Tip**: You may be asked: *"Which line of code will raise a TypeError?"* Recognizing each exception type by its trigger condition is critical for answering such questions quickly and accurately. ### Summary Table | Concept | Key Rule or Insight | Why It Matters | | ------------------- | ---------------------------------------- | ---------------------------------------- | | **Indentation** | Function body must be indented | Python uses indentation to define blocks | | **Default Return** | Functions without `return` return `None` | Can affect logic flow and outputs | | **`NoneType`** | Use `type()` to confirm default return | Clarifies behavior in exam questions | | **Exception Names** | Know 5–6 common errors by name and cause | Used in multiple-choice logic checking | ---

Shopping cart

Subtotal:

Examination Introduction

Learning Method

Study Plan

Skill Practice Questions