# Programming Constructs in Python This document outlines the fundamental data structures and programming constructs in Python, including lists, tuples, sets, dictionaries, file handling, GUI development with Tkinter, and database management with SQLite. ### 3.2.1 List A *list* is a fundamental, sequential data structure in Python that stores an ordered collection of elements. - **Properties:** - *Ordered*: The order in which elements are added is preserved. - *Mutable*: Elements can be added, removed, or changed after the list is created. - *Dynamic*: The size of the list can change as needed. - *Heterogeneous*: Can store elements of different data types (e.g., integers, strings, booleans) in the same list. - **Indexing:** Elements are accessed by their index, starting from 0 for the first element. **Common Operations & Methods:** | Method/Function | Description | Example Code | | :--- | :--- | :--- | | `list = [...]` | Creates a new list. | `student_grades = [85, 92, 78, 95, 82]` | | `.insert(index, value)` | Inserts a `value` at a specific `index`. | `student_grades.insert(2, 90)` | | `.append(value)` | Adds a `value` to the end of the list. | `student_grades.append(100)` | | `.remove(value)` | Removes the first occurrence of a specific `value`. | `student_grades.remove(78)` | | `.pop(index)` | Removes and returns the element at a specific `index`. | `lowest_grade = student_grades.pop(2)` | | `in` operator | Checks if an element exists in the list. | `if 88 in student_grades:` | | `len()` | Returns the number of elements in the list. | `len(student_grades)` | | `sum()` | Returns the sum of all numeric elements in the list. | `sum(student_grades)` | ### 3.2.2 Tuples A *tuple* is an ordered, immutable collection of elements, represented using parentheses `(_, _, _)`. - **Properties:** - *Ordered*: The order of elements is preserved. - *Immutable*: Once created, the contents of a tuple cannot be changed (no adding, removing, or rearranging elements). - **Use Cases:** Ideal for data that should not change, such as days of the week, geographical coordinates, or configuration settings. - **Operations:** - Elements can be accessed by index: `grades[0]`. - The `in` operator can check for an element's existence. - `.count()` method returns the number of times a value appears. - Tuples can be concatenated using the `+` operator to create a new tuple. ### 3.2.3 Sets A *set* is an unordered collection of unique elements, represented using curly braces `{_, _, _}`. - **Properties:** - *Unordered*: Elements have no specific order or index. - *Unique*: A set cannot contain duplicate values; duplicates are automatically removed. - **Use Cases:** Storing unique items like usernames or product IDs, and performing mathematical set operations. - **Operations:** - `.add()` method to add a new element. - The `in` operator to check if an element exists. ### 3.2.4 Dictionary A *dictionary* is a data structure that stores data as *key-value pairs*. Each unique key is associated with a specific value. - **Properties:** - *Key-Value Pairs*: Data is organized by keys, which are used to retrieve their associated values. - *Unique Keys*: Keys within a dictionary must be unique. If a key is added that already exists, its value is updated. - *Mutable Keys*: Keys must be of an immutable data type (e.g., strings, integers, tuples). - *Flexible Values*: Values can be of any data type, including lists or other dictionaries. - *Fast Lookup*: Searching for a value by its key is significantly faster than searching for an element in a list. ### Data Structure Comparison | Feature | List | Tuple | Set | Dictionary | | :--- | :--- | :--- | :--- | :--- | | **Syntax** | `[1, 2, 3]` | `(1, 2, 3)` | `{1, 2, 3}` | `{'a': 1, 'b': 2}` | | **Ordering** | Ordered | Ordered | Unordered | Ordered (Python 3.7+) | | **Mutability**| Mutable | Immutable | Mutable | Mutable | | **Duplicates**| Allowed | Allowed | Not Allowed | Not Allowed (Keys) | | **Access** | By Index | By Index | By Membership | By Key | ### 3.2.5 Nested List A *nested list* is a list that contains other lists as its elements. This structure is commonly used to represent matrices or other multi-dimensional data. - **Example: Matrix** A 3x3 matrix can be represented as `[[1, 2, 3], [4, 5, 6], [7, 8, 9]]`. - **Accessing Elements:** Elements are accessed using double indices, e.g., `matrix[row][col]`. ### 3.2.6 List as a Value in Dictionary A dictionary can store a list as a value for a key. This is useful for associating a single key with multiple pieces of information. - **Example:** Storing student records where the name is the key and the value is a list containing registration number and marks. ```python students = { "Sara": ["345", 85, 90, 78], "Jamal": ["678", 75, 88, 92] } ``` ### 3.2.7 Files in Python File handling allows a program to read from and write to files on a disk, enabling data persistence. - **File Types:** - ***Text File:*** Stores data as characters (e.g., `.txt`, `.csv`). Lines are typically separated by an End Of Line (EOL) marker (`\n`). - ***Binary File:*** Stores data in binary format (0s and 1s) for programs to read. Examples include images (`.webp`), audio (`.mp3`), and executables (`.exe`). - **File Operations:** - `open(filename, mode)`: Opens a file. Modes include `"r"` (read), `"w"` (write, overwrites existing file), and `"a"` (append, adds to end of file). - `read()`: Reads the contents of a file. - `write()`: Writes data to a file. - `close()`: Closes the file to free up system resources. - **Best Practice:** Use the `with` statement to handle files. It automatically closes the file, even if errors occur. ```python with open("abc.txt", "r") as file: content = file.read() ``` - **Error Handling:** Use `try-except` blocks to manage potential errors like `FileNotFoundError`. ### 3.2.8 GUI in Python (Tkinter) A *Graphical User Interface (GUI)* allows users to interact with applications through visual elements like buttons and menus, as opposed to a text-based Command-Line Interface (CLI). - **Tkinter:** Python's built-in library for creating GUIs. - **Core Concepts:** - *Widgets*: The basic components of a GUI, such as buttons (`tk.Button`), labels (`tk.Label`), and text entry boxes (`tk.Entry`). - *Event Handling*: Defining functions that respond to user actions like mouse clicks or key presses. - *Layout Management*: Arranging widgets in the application window using methods like `.grid()` or `.pack()`. ### 3.2.9 Databases A *database* is a structured set of data held in a computer, designed for efficient storage, retrieval, and management. - **Types of Databases:** - ***Relational Database:*** Organizes data into tables with rows and columns (e.g., SQLite, MySQL). - ***NoSQL Database:*** Provides more flexibility for unstructured or semi-structured data. - **Key Concepts:** - *Table*: A collection of related data organized in rows and columns. - *Record*: A single row in a table, representing one entity. - *Field*: A single column in a table, representing an attribute of the entity. - **Database Keys:** - ***Primary Key:*** A field that uniquely identifies each record in a table. - ***Foreign Key:*** A field in one table that refers to the primary key in another table, creating a relationship. - **Data Normalization:** The process of organizing tables in a database to minimize data redundancy and improve data integrity. - **1NF (First Normal Form):** Ensures table cells hold atomic (single) values and removes repeating groups. - **2NF (Second Normal Form):** Is in 1NF and ensures all non-key attributes are fully dependent on the entire primary key. - **3NF (Third Normal Form):** Is in 2NF and eliminates transitive dependencies (where a non-key attribute depends on another non-key attribute). - **SQLite:** A lightweight, serverless, self-contained database engine. The entire database is stored in a single file, making it ideal for mobile apps and small to medium-sized applications.