How to define a variable in Python

Variables form the foundation of Python programming, serving as containers that store data values you can reference and manipulate throughout your code. Understanding how to properly define them unlocks Python's full potential for solving real-world problems.

This guide covers essential variable definition techniques, best practices, and practical applications, complete with code examples created with Claude, an AI assistant built by Anthropic.

Basic variable assignment

name = "John"
age = 30
print(f"Name: {name}, Age: {age}")

Name: John, Age: 30

The code demonstrates two fundamental approaches to variable assignment in Python. The first variable name stores a string value while age holds an integer, showing Python's dynamic typing capabilities. This flexibility lets you assign different data types without explicit type declarations.

Python's = operator creates a reference to the value rather than copying it. This reference-based system offers several advantages:

• More efficient memory usage since values aren't duplicated unnecessarily
• Simplified variable reassignment when working with large data structures
• Consistent behavior across different data types

Basic variable definition techniques

Building on Python's dynamic typing system, let's explore three core aspects of variable definition that make Python code both flexible and maintainable.

Using different data types

integer_var = 10
float_var = 3.14
string_var = "Hello"
boolean_var = True
print(type(integer_var), type(float_var), type(string_var), type(boolean_var))

<class 'int'> <class 'float'> <class 'str'> <class 'bool'>

Python's dynamic typing shines in this example. The code demonstrates four fundamental data types that you'll frequently use in Python development.

• integer_var stores whole numbers without decimal points
• float_var handles decimal numbers with precision
• string_var contains text data enclosed in quotes
• boolean_var represents true/false values

The type() function reveals each variable's data type. Python automatically determines the appropriate type based on the value you assign. This flexibility eliminates the need for explicit type declarations found in other programming languages.

Multiple variable assignment

x, y, z = 1, 2.5, "Python"
a = b = c = 100
print(f"x={x}, y={y}, z={z}")
print(f"a={a}, b={b}, c={c}")

x=1, y=2.5, z=Python
a=100, b=100, c=100

Python offers two powerful ways to assign multiple variables simultaneously. The first method uses tuple unpacking to assign different values to multiple variables in a single line, as shown in x, y, z = 1, 2.5, "Python". The second approach assigns the same value to multiple variables using chained assignment, demonstrated by a = b = c = 100.

• Tuple unpacking requires the number of variables to match the number of values exactly
• Chained assignment creates references to the same value for all variables
• Both methods reduce code verbosity while maintaining readability

These assignment techniques become particularly valuable when working with function returns or handling multiple data points in data processing tasks.

Variable naming conventions

user_name = "alice"      # snake_case (recommended)
UserAge = 25             # PascalCase
isActive = True          # camelCase
_private_var = "secret"  # starting with underscore
print(user_name, UserAge, isActive, _private_var)

alice 25 True secret

Python's variable naming conventions help create readable, maintainable code. The example demonstrates four common naming patterns developers use to convey meaning and intent through their variable names.

• snake_case represents the Python community's preferred style for variable names. It uses lowercase letters with underscores between words, making variables like user_name easy to read
• PascalCase capitalizes each word without spaces. While Python typically reserves this style for class names, some developers use it for constants
• camelCase starts with a lowercase letter and capitalizes subsequent words. Though common in other languages, Python developers rarely use this style
• Variables starting with an underscore like _private_var indicate internal use. This naming pattern tells other developers not to directly access these variables from outside the module

Following these conventions makes your code more professional and easier for other developers to understand. They serve as a form of documentation, revealing the purpose and scope of your variables at a glance.

Advanced variable concepts

Building on Python's flexible typing system and naming conventions, these advanced concepts empower you to write more robust code through type hints, variable scope management, and immutable data structures.

Type hinting with variables

from typing import List, Dict, Union

name: str = "Alice"
age: int = 30
scores: List[int] = [95, 87, 92]
user: Dict[str, Union[str, int]] = {"name": "Bob", "age": 25}
print(f"{name}: {age}, Scores: {scores}")

Alice: 30, Scores: [95, 87, 92]

Type hints add optional static typing to Python's dynamic system, making code more maintainable and easier to debug. The typing module provides specialized type annotations that help catch potential errors before runtime.

• Basic type hints use straightforward annotations like name: str and age: int to specify expected data types
• Complex data structures require nested type hints. List[int] indicates a list containing only integers
• The Union type allows multiple possible types for a value. Union[str, int] accepts either strings or integers
• Dictionary type hints use two parameters: Dict[key_type, value_type] specifies types for both keys and values

Modern code editors and linting tools use these hints to provide better code suggestions and catch type-related issues during development. While Python won't enforce these hints at runtime, they serve as valuable documentation and development aids.

Using global and local variables

global_var = "I'm global"

def show_variables():
    local_var = "I'm local"
    print(global_var)
    print(local_var)

show_variables()
print(global_var)

I'm global
I'm local
I'm global

Python's variable scope rules determine where you can access variables in your code. The example demonstrates two key scoping concepts: global and local variables.

The variable global_var exists in the global scope, making it accessible everywhere in your program. In contrast, local_var lives only inside the show_variables() function. Once the function finishes executing, Python discards the local variable.

• Global variables remain accessible throughout your entire program
• Local variables exist only within their defining function
• Functions can read global variables without special declarations
• Modifying global variables inside functions requires the global keyword

While global variables offer convenience, they can make code harder to maintain. Consider passing variables as function parameters instead. This approach creates more predictable and testable code.

Using constants and immutable variables

import enum

PI = 3.14159  # Convention for constants (uppercase)

class Color(enum.Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

print(f"PI: {PI}, Red value: {Color.RED.value}")

PI: 3.14159, Red value: 1

Python offers two main approaches to create values that shouldn't change during program execution. The uppercase naming convention (like PI = 3.14159) signals to other developers that they shouldn't modify these values, though Python won't enforce this restriction.

For stronger immutability guarantees, the enum module creates true constants through enumerated types. The Color class demonstrates this by defining a fixed set of color options with associated values that remain constant throughout your program's lifecycle.

• Use uppercase names for simple constants you want to protect by convention
• Choose enums when you need a fixed set of related constant values
• Access enum values using dot notation (like Color.RED.value)
• Enums prevent accidental modifications and provide better type safety

Calculating inventory value with the * operator

The * operator enables straightforward multiplication of variables to calculate business metrics like total inventory value, as demonstrated in this example of tracking laptop stock worth.

product_name = "Laptop"
stock_quantity = 15
price = 899.99
inventory_value = stock_quantity * price
print(f"Product: {product_name}")
print(f"Total inventory value: ${inventory_value:.2f}")

This code demonstrates variable assignment and string formatting to calculate inventory value in a retail context. The program stores product details in three variables: product_name for the item label, stock_quantity for units in stock, and price for the per-unit cost. It then multiplies quantity and price to determine total value.

The output uses Python's f-strings to format the results. The :.2f format specifier ensures the monetary value displays with exactly two decimal places. This approach creates clean, professional output that's ready for business reporting.

Processing user data with dictionary variables

Dictionaries in Python provide an elegant way to store and process structured user data by organizing related information like names, ages, and subscription status into key-value pairs that you can efficiently analyze.

users = [
    {"name": "Alice", "age": 28, "premium": True},
    {"name": "Bob", "age": 35, "premium": False},
    {"name": "Charlie", "age": 22, "premium": True}
]

total_age = 0
premium_count = 0
for user in users:
    total_age += user["age"]
    if user["premium"]:
        premium_count += 1

avg_age = total_age / len(users)
print(f"Average user age: {avg_age:.1f}")
print(f"Number of premium users: {premium_count}")

This code processes a list of user dictionaries to calculate key metrics about the user base. The users list contains dictionaries with three fields: name, age, and premium status. A single loop efficiently handles two calculations at once:

• Adds up all user ages to calculate the average age
• Counts how many users have premium status

The code uses Python's dictionary access syntax (user["age"]) to retrieve values. It then calculates the average age by dividing total_age by the number of users. The f-string formatting (:.1f) ensures the average displays with one decimal place.

Common errors and challenges

Python's variable system introduces several common pitfalls that can trip up both new and experienced developers when managing scope, arguments, and references.

Forgetting to use global when modifying variables

One of Python's most common variable-related errors occurs when modifying global variables inside functions. The global keyword tells Python you want to change a variable defined outside the function's scope. Without it, Python creates a new local variable instead.

counter = 0

def increment_counter():
    counter += 1  # This will cause an UnboundLocalError
    return counter

print(increment_counter())

Python creates a new local counter variable inside the function instead of modifying the global one. Since this local variable doesn't have a value before the += operation, Python raises an UnboundLocalError. The solution appears in the next code block.

counter = 0

def increment_counter():
    global counter
    counter += 1
    return counter

print(increment_counter())

Adding the global keyword before counter explicitly tells Python to modify the variable in the global scope. Without this declaration, Python creates a new local variable inside the function instead of updating the global one.

Watch for this issue when you need to modify global variables within functions. Common scenarios include:

• Updating counters or accumulators across multiple function calls
• Maintaining state in game development
• Managing configuration settings throughout your program

While using global solves the immediate problem, consider alternative approaches like passing variables as arguments and returning modified values. This creates more maintainable and testable code.

Using mutable objects as default arguments

Python's default argument behavior can surprise developers when using mutable objects like lists. The default argument creates a single list that persists between function calls instead of generating a fresh one each time. The code below demonstrates this unexpected sharing of the default list.

def add_item(item, inventory=[]):
    inventory.append(item)
    return inventory

print(add_item("sword"))
print(add_item("shield"))  # Both items end up in the same inventory

The add_item() function creates a single list object when Python first defines the function. Each subsequent call references and modifies this same list instead of creating a fresh one. The following code demonstrates the proper implementation.

def add_item(item, inventory=None):
    if inventory is None:
        inventory = []
    inventory.append(item)
    return inventory

print(add_item("sword"))
print(add_item("shield"))  # Creates separate inventories

Using None as the default argument and creating a new list inside the function solves the mutable default argument problem. This pattern ensures each function call starts with a fresh list instead of sharing a single list across all calls.

• Always use immutable defaults (None, numbers, strings) for function arguments
• Create mutable objects inside the function body
• Watch for this issue when working with lists, dictionaries, or sets as default arguments

This pattern appears frequently in data processing and web applications where you handle collections of items. The if inventory is None check provides a clean way to initialize default values while maintaining function flexibility.

Modifying lists through multiple references

Python's reference-based variable system can create unexpected behavior when working with lists. Multiple variables pointing to the same list will reflect changes made through any reference. This common pitfall affects developers who assume Python creates a new copy when assigning lists to different variables.

original = [1, 2, 3]
duplicate = original
duplicate.append(4)
print(f"Original: {original}, Duplicate: {duplicate}")

When you assign original to duplicate, Python creates a new reference to the same list object instead of copying the data. Any changes to either variable will affect both. Let's examine the corrected approach in the next example.

original = [1, 2, 3]
duplicate = original.copy()
duplicate.append(4)
print(f"Original: {original}, Duplicate: {duplicate}")

The copy() method creates a new list with the same values instead of just creating another reference to the original list. This prevents unintended modifications when you need to work with separate copies of data.

Watch for this behavior when passing lists to functions or storing them in data structures. Python's reference system affects all mutable objects including dictionaries and custom classes.

• Use copy() for shallow copies of simple lists
• Consider deepcopy() from the copy module for nested data structures
• Remember that assignment operators create references not copies