In Python, a
variable is a symbolic name that references or points to a value. Variables are
fundamental in programming because they allow you to store, modify, and
retrieve data during the execution of a program.
### 1.
**What is a Variable?**
- A variable is a name given to a data
value. In Python, you don't need to declare a variable before using it. You
simply assign a value to a variable, and Python automatically determines the
data type based on the value.
- **Naming Conventions**:
- Must start with a letter (a-z, A-Z) or
an underscore (_).
- Cannot start with a number.
- Can contain letters, numbers, and
underscores.
- Python variables are case-sensitive
(`myVar` and `myvar` are different variables).
**Example**:
```python
x = 10
name = "Alice"
is_active = True
```
- Here, `x`, `name`, and `is_active` are
variables that store different types of values.
### 2.
**Variable Assignment**
- Variables are assigned values using the
equals sign `=`. The syntax is `variable_name = value`.
- Python allows you to reassign variables,
meaning you can change the value of a variable at any time.
**Example**:
```python
age = 25
age = 26
# Reassigning the variable to a new value
print(age)
# Output: 26
```
- In the example above, `age` is first
assigned the value `25`, and then it is reassigned to `26`.
### 3.
**Multiple Assignment**
- Python allows you to assign values to
multiple variables in a single line.
**Example**:
```python
a, b, c = 1, 2, 3
print(a)
# Output: 1
print(b)
# Output: 2
print(c)
# Output: 3
```
- Here, `a`, `b`, and `c` are assigned the
values `1`, `2`, and `3` respectively.
- You can also assign the same value to
multiple variables simultaneously.
**Example**:
```python
x = y = z = 100
print(x, y, z) # Output: 100 100 100
```
### 4.
**Data Types**
- The type of value stored in a variable
determines its **data type**. Python is a dynamically-typed language, which
means you don’t need to specify the data type of a variable; Python determines
it based on the value assigned.
- Common data types include:
- `int` (integer): `x = 10`
- `float` (floating-point number): `y =
3.14`
- `str` (string): `name =
"Alice"`
- `bool` (boolean): `is_active = True`
- `list`: `numbers = [1, 2, 3]`
- `tuple`: `coordinates = (10.0, 20.0)`
- `dict`: `person = {"name":
"Alice", "age": 25}`
- `set`: `unique_numbers = {1, 2, 3}`
**Example**:
```python
x = 10
# int
y = 3.14
# float
name = "John" # str
is_raining = False # bool
```
### 5.
**Type Casting**
- Sometimes, you may need to convert a
variable from one type to another. This is called type casting.
- Python provides built-in functions like
`int()`, `float()`, `str()`, `list()`, etc., for type casting.
**Example**:
```python
x = "100" # str
y = int(x)
# Now y is an integer with the value 100
print(y)
# Output: 100
```
- In the example above, the string
`"100"` is converted to an integer using `int()`.
### 6.
**Global and Local Variables**
- **Local Variables**: Defined inside a
function and can only be used within that function.
- **Global Variables**: Defined outside of
all functions and can be accessed globally throughout the program.
- If you need to modify a global variable
inside a function, you must use the `global` keyword.
**Example**:
```python
x = 10
# Global variable
def my_function():
global x
x = 20
# Modify global variable inside the function
print(x)
my_function() # Output: 20
print(x)
# Output: 20
```
- Here, the global variable `x` is modified
inside `my_function()`.
### 7.
**Variable Scope**
- The scope of a variable determines where
it can be accessed. Variables defined inside a function have **local scope**
(accessible only within the function), while variables defined outside of any
function have **global scope**.
**Example**:
```python
def my_function():
a = 5
# Local variable
print(a)
my_function() # Output: 5
# print(a)
# This would cause an error because 'a' is not defined globally
```
###
Conclusion
Variables in
Python are versatile and easy to use, allowing you to store and manipulate
different types of data. By understanding how to properly assign, use, and
manage variables, you can write more efficient and organized Python code.
