# Python Variables In Python, variables are fundamental building blocks used to store and manage data. Understanding how to name, assign, and track these variables is essential for effective programming. ## 1. What is a Variable? A *variable* is a named location in memory used to store information that can be referenced and manipulated later in a program. - **Purpose:** Instead of recalculating a value used multiple times, you can store it in a variable and reuse it, making the code more efficient and readable. - **Good Practice:** Use meaningful and descriptive names for variables (e.g., `user_age` instead of `x`). ## 2. Variable Naming Rules In Python, variable names (also known as identifiers) must follow specific rules: - They can be *alphanumeric* (a combination of letters and numbers) and include underscores (`_`), but **cannot start with a number**. - They are **Case Sensitive**, meaning `Num` and `num` are treated as two different variables. - They **cannot contain spaces**. The underscore character (`_`) is often used to separate words in a variable name (e.g., `temp_var`). ## 3. Program Execution and Logical Bugs - **Sequential Execution:** Instructions in a program are typically executed in the order they are written. Changing this sequence can lead to incorrect or undesirable results. - **Logical Bug (Bug):** A *logical bug* is an error in a program's logic that causes it to produce incorrect results, even though the code's syntax is correct. These bugs can be difficult to find just by looking at the code. ### Example: Swapping Two Variables The following examples demonstrate the importance of instruction order when swapping the values of two variables, `x` and `y`, using a temporary variable, `temp`. **Correct Implementation (Fig 3.10)** This code correctly swaps the values. | Code | Output | | :--- | :--- | | `1. x = 5`
`2. y = 3`
`3. temp = 0`
`4. print('Values of x:', x, 'and y:', y)`
`5. print("Let's Swap the value of x & y")`
`6. temp = x`
`7. x = y`
`8. y = temp`
`9. print('Values of x:', x, 'and y:', y)` | `Values of x: 5 and y: 3`
`Let's Swap the values of x & y`
`Values of x: 3 and y: 5` |
**Incorrect Implementation with a Bug (Fig 3.11)** A small change in the sequence (line 7 and 8 swapped) leads to a logical bug where the original value of `y` is lost. | Code | Output | | :--- | :--- | | `1. x = 5`
`2. y = 3`
`3. temp = 0`
`4. print('Values of x:', x, 'and y:', y)`
`5. print("Let's Swap the value of x & y")`
`6. temp = x`
`7. y = temp`
`8. x = y`
`9. print('Values of x:', x, 'and y:', y)` | `Values of x: 5 and y: 3`
`Let's Swap the values of x & y`
`Values of x: 5 and y: 5` | ## 4. Debugging with a Dry-Run A **Dry-Run** is a simple debugging technique where you manually execute a program on paper, step-by-step, tracking the state and values of all variables at each line of code. This helps identify where the logic goes wrong. **Dry-Run for the Incorrect Code (Fig 3.11)** | Line | `x` | `y` | `temp` | **Comment** | | :---: | :---: | :---: | :---: | :--- | | **Before Line 6** | 5 | 3 | 0 | Initial values. | | **After Line 6** (`temp = x`) | 5 | 3 | **5** | `temp` now holds the value of `x`. | | **After Line 7** (`y = temp`) | 5 | **5** | 5 | `y` is updated to the value of `temp` (5). The original value of `y` (3) is now lost. | | **After Line 8** (`x = y`) | **5** | 5 | 5 | `x` is updated to the current value of `y` (5). The swap fails. | This dry-run clearly shows that at line 7, the original value of `y` (which was 3) is overwritten before it can be assigned to `x`, causing the bug. ## 5. Basic Python Data Types A variable must have a defined *data type* that specifies what kind of data it can hold. Python uses **Dynamic Typing**, meaning you don't have to declare the type explicitly. Python supports several built-in data types: - **Numeric Types:** For storing numbers. - `int`: Integers (e.g., `5`, `-10`). - `float`: Floating-point numbers (e.g., `3.14`, `-0.5`). - `string`: For storing sequences of characters (text). - `list`: A collection of items that is ordered and *mutable* (changeable). Represented with square brackets `[]`. - `tuple`: A collection of items that is ordered and *immutable* (unchangeable). Represented with parentheses `()`. | Data Type | Description | Example | | :--- | :--- | :--- | | `int`, `float` | Numeric values | `10`, `99.9` | | `string` | Sequence of characters | `"Hello, World!"` | | `list` | Ordered, **mutable** collection | `[1, "apple", 3.0]` | | `tuple` | Ordered, **immutable** collection | `(1, "apple", 3.0)` |