← Back to Cheat Sheet

Understanding Variables in Python

What are Variables?

In Python, variables are fundamental building blocks that serve as containers for storing data. Think of variables as labeled boxes where you can store different types of information - numbers, text, lists, or more complex data structures.

Unlike some other programming languages, Python makes working with variables straightforward and intuitive. You don't need to declare variable types explicitly - Python figures this out automatically, making it particularly friendly for beginners.

Real-World Analogy

Imagine you're organizing your desk. You might have:

  • A drawer labeled "supplies" containing pens and papers
  • A container marked "important" holding crucial documents
  • A spot designated "current work" for ongoing projects

Variables in Python work similarly - they're labels that help you organize and access your data. Just as you can change what's in your desk drawer, you can change what's stored in a variable.

Your First Variables

# Creating your first variables
message = "Hello, Python!"
user_age = 25
price = 19.99
is_available = True

# Print them to see their values
print(message)       # Shows: Hello, Python!
print(user_age)      # Shows: 25
print(price)         # Shows: 19.99
print(is_available)  # Shows: True

How Variables Work in Python

When you create a variable in Python, three things happen:

  1. Python allocates memory to store your data
  2. The data is stored in that memory location
  3. The variable name becomes a reference to that memory location

This process is different from languages like C++ or Java, where you need to declare the type of data a variable will hold. Python's approach is called "dynamic typing" - variables can hold different types of data, and you can change the type of data during program execution.

Variable Assignment in Action

Let's break down what happens when you create and modify variables: 

# Creating a variable
name = "Alice"   # Python creates space in memory for "Alice"
                # and 'name' points to it

# Changing the value
name = "Bob"     # The old value "Alice" is released
                # 'name' now points to "Bob"

# Changing the type
name = 42        # Python allows this! The variable now holds a number
                # This is dynamic typing in action

This flexibility is both powerful and requires careful attention. While convenient, it means you need to be aware of what type of data your variables are holding at any given time.

Naming Your Variables

Choosing good variable names is crucial for writing readable and maintainable code. While Python gives you a lot of freedom in naming variables, following these conventions will make your code more professional and easier to understand.

Rules for Variable Names

  • Must start with a letter (a-z, A-Z) or underscore (_)
  • Can contain letters, numbers, and underscores
  • Cannot start with a number
  • Cannot use Python keywords (like 'if', 'for', 'while')
  • Case-sensitive (age, Age, and AGE are different variables)

Best Practices

  • Use descriptive names that explain the variable's purpose
  • Use snake_case for variable names (words separated by underscores)
  • Keep names concise but meaningful
  • Avoid single-letter names except for simple counters

Good vs Bad Variable Names

# Good variable names
user_name = "John Smith"
total_score = 95
is_active = True
items_in_cart = 5

# Poor variable names (avoid these)
a = "John Smith"      # Too vague
un = "John Smith"     # Unclear abbreviation
x1 = 95              # Meaningless name
temp = True          # Ambiguous purpose

Understanding Data Types

While Python handles types automatically, understanding the basic data types is essential for effective programming. Here are the most common types you'll work with:

Basic Data Types

1. Strings (str)

Text data, enclosed in single or double quotes. Strings are immutable, meaning once created, they cannot be changed.

2. Numbers

  • Integers (int): Whole numbers without decimal points
  • Floating-point (float): Numbers with decimal points
  • Complex numbers (complex): Numbers with real and imaginary parts

3. Boolean (bool)

Represents True or False values, used for logical operations and control flow.

Working with Different Types

# Strings
name = "Alice"
message = 'Hello, ' + name    # String concatenation
print(message)               # Output: Hello, Alice

# Numbers
age = 25                    # Integer
height = 1.75              # Float
complex_num = 3 + 4j       # Complex number

# Boolean
is_student = True
has_license = False

# Checking types
print(type(name))          # <class 'str'>
print(type(age))           # <class 'int'>
print(type(height))        # <class 'float'>
print(type(is_student))    # <class 'bool'>

Converting Between Types

Often in programming, you'll need to convert data from one type to another. Python provides built-in functions for type conversion (also called type casting).

Common Type Conversions

Here are the most frequently used type conversion functions:

  • str(): Converts to string
  • int(): Converts to integer
  • float(): Converts to floating-point number
  • bool(): Converts to boolean

Type Conversion Examples

# String to number conversions
age_str = "25"
age_int = int(age_str)      # Convert string to integer
age_float = float(age_str)  # Convert string to float

# Number to string conversion
price = 19.99
price_str = str(price)      # Convert number to string

# Common conversion scenarios
user_input = input("Enter a number: ")  # input() always returns string
number = int(user_input)               # Convert to integer for calculations

# Boolean conversions
print(bool(1))        # True
print(bool(0))        # False
print(bool(""))       # False (empty string)
print(bool("text"))   # True (non-empty string)

Important Note: Type conversion can raise errors if the conversion isn't possible. Always validate your data or use try-except blocks when converting types.

Common Mistakes and How to Avoid Them

When working with variables, there are several common mistakes that beginners often make. Understanding these will help you write better code and avoid frustrating errors.

1. Using Variables Before Assignment

# This will raise an error
# print(x)  # NameError: name 'x' is not defined

# Correct way
x = 10
print(x)  # Works fine

2. Case Sensitivity Issues

name = "Alice"
# print(Name)  # Error: Name is not defined
print(name)    # Works: prints Alice

3. Type Mismatch Operations

# This will raise an error
number = "5"
# result = number + 10  # TypeError

# Correct way
number = int("5")
result = number + 10  # Works: result = 15

Practice Exercises

The best way to learn about variables is through practice. Try these exercises to reinforce your understanding:

Exercise 1: Basic Variable Usage

# Create variables for:
# 1. Your name
# 2. Your age
# 3. Your height in meters
# 4. Whether you're a student (True/False)

# Print all variables and their types

Exercise 2: Type Conversion

# 1. Convert "123" to an integer
# 2. Convert 123 to a string
# 3. Convert 12.34 to an integer
# 4. Convert True to a string

Exercise 3: Variable Manipulation

# 1. Create two number variables
# 2. Perform basic arithmetic (+, -, *, /)
# 3. Store results in new variables
# 4. Print all results

Advanced String Formatting with Variables

1. F-Strings (Python 3.6+)

name = "Alice"
age = 25
# Basic f-string
print(f"Name: {name}, Age: {age}")

# Expressions in f-strings
print(f"Age in 5 years: {age + 5}")

# Formatting specifiers
price = 19.99
print(f"Price: ${price:.2f}")  # Two decimal places

# Date formatting
from datetime import datetime
now = datetime.now()
print(f"Date: {now:%Y-%m-%d}")

2. Format Method

# Basic formatting
print("Hello, {}!".format(name))

# Multiple values
print("Name: {}, Age: {}".format(name, age))

# Named placeholders
print("Name: {n}, Age: {a}".format(n=name, a=age))

3. % Operator (Legacy)

# Old style formatting (still works but not recommended)
print("Name: %s, Age: %d" % (name, age))

Variable Scope in Python

Understanding variable scope is crucial for Python programming. It determines where variables can be accessed and modified.

Scope Examples

# Global scope
global_var = "I'm accessible everywhere"

def my_function():
    # Local scope
    local_var = "I'm only accessible inside this function"
    print(local_var)
    print(global_var)  # Global variables are accessible

# Modifying global variables
def modify_global():
    global global_var
    global_var = "Modified"  # Changes the global variable

# Nested scope (enclosing)
def outer():
    outer_var = "I'm in outer function"
    def inner():
        print(outer_var)  # Can access outer_var
    inner()

Memory Management and Variables

# Variable assignment and memory
x = [1, 2, 3]
y = x  # Both variables point to the same list

# Mutable vs Immutable types
string = "hello"
string = string + " world"  # Creates new string object

list_example = [1, 2]
list_example.append(3)  # Modifies existing list

# Memory cleanup
import sys
print(sys.getrefcount(x))  # Check reference count

# del statement
del x  # Removes reference to object
# Object may be garbage collected if no more references exist

Special Variables in Python

# Built-in special variables
print(__name__)  # '__main__' if run directly

# Private variables (name mangling)
class MyClass:
    def __init__(self):
        self.__private = "Can't access easily"  # Name mangling
        self._protected = "Convention only"     # Convention for protected

# Special method variables
def my_function():
    print(f"Function name: {my_function.__name__}")
    print(f"Doc string: {my_function.__doc__}")

Type Hints and Annotations

# Basic type hints (Python 3.6+)
name: str = "Alice"
age: int = 25
height: float = 1.75

# Function type hints
def greet(name: str) -> str:
    return f"Hello, {name}"

# Complex type hints
from typing import List, Dict, Optional

def process_users(users: List[str]) -> Dict[str, int]:
    return {user: len(user) for user in users}

# Optional values
def find_user(id: int) -> Optional[str]:
    users = {1: "Alice", 2: "Bob"}
    return users.get(id)  # Returns None if not found

Core Concepts of Variables

Variables in Python act as symbolic names that reference values stored in memory. Unlike lower-level languages like C, Python variables don't actually "contain" values - they serve as labels pointing to objects in memory. This fundamental difference leads to some unique behaviors that are crucial to understand for effective Python programming.

Variable Lifecycle Example

# Creation Phase
website_name = "PythonCheatSheet"  # Python allocates memory for string
visitor_count = 0                 # Creates integer object

# Usage Phase
print(f"Welcome to {website_name}")  
visitor_count += 1  # Creates new integer object (immutability in action)

# Reassignment Phase
website_name = 42  # Dynamic typing allows type change
del visitor_count  # Marks for garbage collection

Memory Management Deep Dive

Python uses automatic memory management through reference counting and garbage collection. When you create a variable, Python:

  1. Allocates memory for the object
  2. Sets the reference count to 1
  3. Binds the variable name to the object

Variable Operations

Naming Conventions

# Valid names
my_variable = 10
_variable    = 20
variable2   = 30

# Invalid names
# 2variable  = 40   # Can't start with number
# my-variable = 50  # No hyphens
# $variable   = 60  # No special characters

Common Type Methods

# String methods
text = "  python  "
print(text.strip().upper())   # "PYTHON"

# List methods
numbers = [1, 2, 3]
numbers.append(4)
print(numbers)                # [1, 2, 3, 4]

# Dictionary methods
user = {"name": "Alice", "age": 30}
print(user.keys())            # dict_keys(['name', 'age'])

Advanced Assignment

# Tuple unpacking
coordinates  = (34.0522, -118.2437)
lat, lon     = coordinates

# Swapping variables
a, b         = 10, 20
a, b         = b, a          # a=20, b=10

# Starred assignment
first, *rest = [1, 2, 3, 4]  # first=1, rest=[2, 3, 4]

Advanced Type Conversion

While basic type conversion is straightforward, understanding edge cases and potential pitfalls is crucial for robust code. Python's conversion functions have specific behaviors that vary by input type: 

# String to Number Conversions
print(int("1010", 2))     # Binary conversion: 10
print(float("inf"))       # Special float value: infinity
print(int(" 42 "))        # Handles whitespace: 42

# Boolean Truth Testing
print(bool([]))           # Empty list: False
print(bool("False"))      # Non-empty string: True
print(bool(0.0))          # Zero float: False

# Complex Conversions
print(complex(3, 4))      # (3+4j)
print(int(3.999))         # Truncates to 3 (doesn't round)

Variable Scope Hierarchy

# LEGB Rule (Local -> Enclosing -> Global -> Built-in)
global_var = "I'm global"

def outer_function():
    enclosing_var = "I'm enclosing"
    
    def inner_function():
        local_var = "I'm local"
        print(local_var)        # Local scope
        print(enclosing_var)    # Enclosing scope
        print(global_var)       # Global scope
        print(len)              # Built-in scope
    
    inner_function()

# Demonstrate scope hierarchy
outer_function()

Best Practices for Scope Management

  • Avoid modifying global variables inside functions
  • Use closure variables for encapsulation
  • Prefer class attributes over global state
  • Use nonlocal keyword judiciously