"""

================================================================================

File: 03_variables.py

Topic: Variables in Python

================================================================================

This file demonstrates how to create and use variables in Python. Variables

are containers for storing data values. Unlike other programming languages,

Python has no command for declaring a variable - it's created the moment

you assign a value to it.

Key Concepts:

- Variable creation and assignment

- Variable naming conventions

- Multiple assignments

- Variable types and type checking

- Constants

- Variable scope basics

================================================================================

"""

# -----------------------------------------------------------------------------

# 1. Creating Variables

# -----------------------------------------------------------------------------

# Variables are created when you assign a value to them

print("--- Creating Variables ---")

# Simple variable assignments

name = "Baraa"

age = 25

height = 1.75

is_student = True

print(f"Name: {name}")

print(f"Age: {age}")

print(f"Height: {height}m")

print(f"Is student: {is_student}")

# Variables can be reassigned to different values

x = 10

print(f"\nx = {x}")

x = 20

print(f"x = {x} (reassigned)")

# Variables can even change types (dynamic typing)

value = 100

print(f"\nvalue = {value} (type: {type(value).__name__})")

value = "one hundred"

print(f"value = {value} (type: {type(value).__name__})")

# -----------------------------------------------------------------------------

# 2. Variable Naming Rules

# -----------------------------------------------------------------------------

# Rules for Python variable names

print("\n--- Variable Naming Rules ---")

# ✅ Valid variable names

my_variable = 1 # Lowercase with underscores (snake_case) - RECOMMENDED

myVariable = 2 # camelCase - valid but not Pythonic

MyVariable = 3 # PascalCase - usually for classes

_private_var = 4 # Starts with underscore - convention for private

__very_private = 5 # Double underscore - name mangling

var123 = 6 # Can contain numbers (but not start with them)

CONSTANT = 7 # ALL CAPS - convention for constants

print(f"my_variable = {my_variable}")

print(f"_private_var = {_private_var}")

print(f"CONSTANT = {CONSTANT}")

# ❌ Invalid variable names (would cause errors):

# 123var = 1 # Cannot start with a number

# my-variable = 1 # Hyphens not allowed

# my variable = 1 # Spaces not allowed

# class = 1 # Cannot use reserved keywords

# Reserved keywords in Python (cannot use as variable names):

import keyword

print(f"\nPython reserved keywords: {keyword.kwlist[:10]}...")

# -----------------------------------------------------------------------------

# 3. Naming Conventions (PEP 8)

# -----------------------------------------------------------------------------

print("\n--- Naming Conventions (PEP 8) ---")

# Variables and functions: snake_case

user_name = "john_doe"

max_value = 100

is_active = True

# Constants: UPPER_SNAKE_CASE

PI = 3.14159

MAX_CONNECTIONS = 100

DEFAULT_TIMEOUT = 30

# Classes: PascalCase (CapWords)

# class MyClass:

# pass

# Private variables: leading underscore

_internal_state = "private"

# "Very private" / Name-mangled: double leading underscore

__name_mangled = "mangled"

print(f"user_name: {user_name}")

print(f"PI (constant): {PI}")

print(f"MAX_CONNECTIONS (constant): {MAX_CONNECTIONS}")

# Descriptive names are better than short names

# ✅ Good

total_price = 99.99

customer_name = "Alice"

is_logged_in = True

# ❌ Bad (avoid!)

# tp = 99.99

# cn = "Alice"

# il = True

# -----------------------------------------------------------------------------

# 4. Multiple Variable Assignment

# -----------------------------------------------------------------------------

print("\n--- Multiple Variable Assignment ---")

# Assign the same value to multiple variables

a = b = c = 100

print(f"a = {a}, b = {b}, c = {c}")

# Assign different values in one line

x, y, z = 1, 2, 3

print(f"x = {x}, y = {y}, z = {z}")

# Swap variables easily

print(f"\nBefore swap: x = {x}, y = {y}")

x, y = y, x

print(f"After swap: x = {x}, y = {y}")

# Unpack a list/tuple into variables

coordinates = (10, 20, 30)

x, y, z = coordinates

print(f"\nUnpacked coordinates: x={x}, y={y}, z={z}")

# Extended unpacking with *

first, *rest = [1, 2, 3, 4, 5]

print(f"first = {first}, rest = {rest}")

*beginning, last = [1, 2, 3, 4, 5]

print(f"beginning = {beginning}, last = {last}")

first, *middle, last = [1, 2, 3, 4, 5]

print(f"first = {first}, middle = {middle}, last = {last}")

# -----------------------------------------------------------------------------

# 5. Variable Types and Type Checking

# -----------------------------------------------------------------------------

print("\n--- Variable Types and Type Checking ---")

# Python is dynamically typed - types are determined at runtime

integer_var = 42

float_var = 3.14

string_var = "Hello"

bool_var = True

list_var = [1, 2, 3]

dict_var = {"key": "value"}

none_var = None

# Check types using type()

print(f"integer_var: {integer_var} -> {type(integer_var)}")

print(f"float_var: {float_var} -> {type(float_var)}")

print(f"string_var: {string_var} -> {type(string_var)}")

print(f"bool_var: {bool_var} -> {type(bool_var)}")

print(f"list_var: {list_var} -> {type(list_var)}")

print(f"dict_var: {dict_var} -> {type(dict_var)}")

print(f"none_var: {none_var} -> {type(none_var)}")

# Check if variable is of a specific type using isinstance()

print(f"\nIs integer_var an int? {isinstance(integer_var, int)}")

print(f"Is string_var a str? {isinstance(string_var, str)}")

print(f"Is list_var a list? {isinstance(list_var, list)}")

# Check multiple types

print(f"Is integer_var int or float? {isinstance(integer_var, (int, float))}")

# -----------------------------------------------------------------------------

# 6. Type Casting (Converting Types)

# -----------------------------------------------------------------------------

print("\n--- Type Casting ---")

# String to integer

str_num = "123"

int_num = int(str_num)

print(f"'{str_num}' (str) -> {int_num} (int)")

# String to float

str_float = "3.14"

float_num = float(str_float)

print(f"'{str_float}' (str) -> {float_num} (float)")

# Number to string

number = 42

str_number = str(number)

print(f"{number} (int) -> '{str_number}' (str)")

# Float to integer (truncates, doesn't round)

pi = 3.99

int_pi = int(pi)

print(f"{pi} (float) -> {int_pi} (int) [truncated]")

# Boolean conversions

print(f"\nbool(1) = {bool(1)}") # True

print(f"bool(0) = {bool(0)}") # False

print(f"bool('hello') = {bool('hello')}") # True

print(f"bool('') = {bool('')}") # False

print(f"bool([1, 2]) = {bool([1, 2])}") # True

print(f"bool([]) = {bool([])}") # False

# Integer to boolean

print(f"\nint(True) = {int(True)}") # 1

print(f"int(False) = {int(False)}") # 0

# -----------------------------------------------------------------------------

# 7. Constants

# -----------------------------------------------------------------------------

print("\n--- Constants ---")

# Python doesn't have true constants, but by convention:

# - Use UPPER_SNAKE_CASE for constants

# - Don't modify them after initial assignment

# Mathematical constants

PI = 3.14159265359

E = 2.71828182845

GOLDEN_RATIO = 1.61803398875

# Application constants

MAX_USERS = 1000

API_TIMEOUT = 30

BASE_URL = "https://api.example.com"

DEBUG_MODE = False

print(f"PI = {PI}")

print(f"MAX_USERS = {MAX_USERS}")

print(f"BASE_URL = {BASE_URL}")

# You CAN modify them (Python won't stop you), but you SHOULDN'T

# PI = 3 # Don't do this!

# For true constants, you can use:

# 1. Separate constants module (constants.py)

# 2. typing.Final (Python 3.8+)

from typing import Final

MAX_SIZE: Final = 100

# MAX_SIZE = 200 # Type checker will warn about this

print(f"MAX_SIZE (Final) = {MAX_SIZE}")

# -----------------------------------------------------------------------------

# 8. Variable Scope (Basic)

# -----------------------------------------------------------------------------

print("\n--- Variable Scope ---")

# Global variable

global_var = "I'm global"

def my_function():

# Local variable

local_var = "I'm local"

print(f"Inside function - global_var: {global_var}")

print(f"Inside function - local_var: {local_var}")

my_function()

print(f"Outside function - global_var: {global_var}")

# print(local_var) # Error! local_var doesn't exist here

# Modifying global variables inside functions

counter = 0

def increment():

global counter # Declare we want to use global counter

counter += 1

print(f"\nBefore increment: counter = {counter}")

increment()

increment()

print(f"After 2 increments: counter = {counter}")

# -----------------------------------------------------------------------------

# 9. Variable Identity and Memory

# -----------------------------------------------------------------------------

print("\n--- Variable Identity and Memory ---")

# id() returns the memory address of a variable

a = 10

b = 10

c = a

print(f"a = {a}, id(a) = {id(a)}")

print(f"b = {b}, id(b) = {id(b)}")

print(f"c = {c}, id(c) = {id(c)}")

# Small integers (-5 to 256) are cached in Python

print(f"\na is b: {a is b}") # True (same memory location)

print(f"a is c: {a is c}") # True

# Larger numbers may have different ids

x = 1000

y = 1000

print(f"\nx = {x}, id(x) = {id(x)}")

print(f"y = {y}, id(y) = {id(y)}")

# 'is' vs '=='

list1 = [1, 2, 3]

list2 = [1, 2, 3]

list3 = list1

print(f"\nlist1 == list2: {list1 == list2}") # True (same values)

print(f"list1 is list2: {list1 is list2}") # False (different objects)

print(f"list1 is list3: {list1 is list3}") # True (same object)

# -----------------------------------------------------------------------------

# 10. Deleting Variables

# -----------------------------------------------------------------------------

print("\n--- Deleting Variables ---")

temp_var = "I will be deleted"

print(f"temp_var exists: {temp_var}")

del temp_var

# print(temp_var) # Error! NameError: name 'temp_var' is not defined

print("temp_var has been deleted")

# Check if variable exists

if 'temp_var' not in dir():

print("temp_var no longer exists in current scope")

# -----------------------------------------------------------------------------

# 11. Practical Examples

# -----------------------------------------------------------------------------

print("\n--- Practical Examples ---")

# Example 1: User profile

first_name = "Baraa"

last_name = "Shaer"

full_name = f"{first_name} {last_name}"

email = f"{first_name.lower()}.{last_name.lower()}@example.com"

print(f"Full Name: {full_name}")

print(f"Email: {email}")

# Example 2: Shopping cart

item_price = 29.99

quantity = 3

discount_percent = 10

subtotal = item_price * quantity

discount_amount = subtotal * (discount_percent / 100)

total = subtotal - discount_amount

print(f"\nSubtotal: ${subtotal:.2f}")

print(f"Discount ({discount_percent}%): -${discount_amount:.2f}")

print(f"Total: ${total:.2f}")

# Example 3: Temperature conversion

celsius = 25

fahrenheit = (celsius * 9/5) + 32

kelvin = celsius + 273.15

print(f"\n{celsius}°C = {fahrenheit}°F = {kelvin}K")

# -----------------------------------------------------------------------------

# Summary

# -----------------------------------------------------------------------------

print("\n" + "=" * 60)

print("VARIABLES SUMMARY")

print("=" * 60)

print("""

1. Variables are created by assignment (=)

2. Python is dynamically typed

3. Use snake_case for variables (PEP 8)

4. Use UPPER_CASE for constants

5. Multiple assignments: x, y, z = 1, 2, 3

6. Check types with type() or isinstance()

7. Convert types with int(), str(), float(), bool()

8. Variables have scope (local vs global)

9. Use 'is' for identity, '==' for equality

10. Delete variables with 'del'

""")