Python Variables and Data Types Explained

Why Variables in Python Aren't What You Think They Are

If you learned programming in Java, C++, or C#, you're used to the idea that a variable is a container. You declare a box, you put a value in it, and that value lives there until you change it.

Python doesn't work that way. Variables in Python are labels, not boxes. They're tags you attach to objects in memory.

When you write:

x = 5

You're not creating a container called x. You're creating an integer object with the value 5, and then creating a label called x that points to that object. Subtle distinction? Sure. But it changes everything about how the language behaves.

Why does this matter? Because multiple labels can point to the same object. One label can move from one object to another. Objects can exist even after you remove the label pointing to them. These concepts are foreign if you're thinking of variables as boxes, but they're natural if you think of them as labels.

Let's make this concrete. If you write:

x = 5
y = x

You haven't copied the value 5 into a new box. You've created two labels pointing to the same object. Both x and y point to the integer 5 in memory. With numbers, this distinction doesn't matter much because integers are immutable, you can't change the 5 that both labels point to. But with mutable objects like lists? That's where things get wild.

We'll get there. First, let's establish what types Python actually gives you.

The Built-In Data Types: Your Toolkit

Python gives you a rich set of types right out of the box. You don't need to import anything or declare what type something is, Python figures it out automatically. This is called dynamic typing. The tradeoff is that you need to keep track of types mentally, since Python won't stop you from putting an integer where a string belongs until something actually breaks at runtime.

Here are the core types you'll reach for constantly:

Integers (int)

A whole number, positive or negative. No decimal point. Integers show up everywhere, loop counters, array indices, age fields, quantity tracking, you name it.

age = 25
temperature = -10
big_number = 1_000_000
# Output: These are all integers
 
print(type(age))
# output: <class 'int'>
 
print(type(-10))
# output: <class 'int'>

Python 3 has arbitrary precision, meaning integers can be as large as your memory allows. That 1_000_000 above uses underscores for readability, Python ignores them, but your eyes appreciate the clarity. This arbitrary precision is a genuinely useful feature when you get into cryptography or certain AI/ML calculations where numbers get astronomically large.

Floats (float)

A decimal number. Any number with a decimal point is a float, even 1.0. You'll use floats for prices, measurements, scientific calculations, probabilities in ML models, and any math that needs fractional precision.

price = 9.99
pi = 3.14159
negative_float = -0.5
 
print(type(price))
# output: <class 'float'>
 
print(type(1.0))
# output: <class 'float'>

Floats are stored in binary, which sometimes leads to precision quirks. Don't be alarmed if you see something like this:

result = 0.1 + 0.2
print(result)
# output: 0.30000000000000004

That's floating-point arithmetic for you, a topic for another time. Just know that floats are approximate, not exact. For financial calculations where precision matters, look into Python's decimal module instead.

Complex Numbers (complex)

For the math-heavy folks, Python has built-in support for complex numbers with both real and imaginary parts. If you're heading toward signal processing or certain areas of scientific computing, you'll encounter these often.

z = 3 + 4j
real_part = z.real
imaginary_part = z.imag
 
print(type(z))
# output: <class 'complex'>
 
print(real_part)
# output: 3.0
 
print(imaginary_part)
# output: 4.0

Most web development and data science won't touch complex numbers, but they're there if you need them.

Booleans (bool)

The simplest type: True or False. That's it. Just two values. Booleans are the backbone of every conditional and loop in your programs, they're what makes decisions possible in code.

is_raining = True
is_sunny = False
 
print(type(is_raining))
# output: <class 'bool'>
 
if is_raining:
    print("Bring an umbrella")
# output: Bring an umbrella

Here's something important: in Python, True and False are exactly equal to the integers 1 and 0, respectively. This is usually not what you want, so avoid relying on it. Just use booleans for what they're meant for, conditions. That said, this relationship becomes useful when you're doing things like counting how many items in a list satisfy a condition, since you can sum a list of booleans directly.

Strings (str)

Text. Sequences of characters wrapped in quotes. You can use single quotes, double quotes, or triple quotes. Strings are arguably the type you'll spend the most time working with, user input, API responses, file contents, configuration values, log messages, and countless other things all live as strings.

name = "Alice"
message = 'Hello, world!'
multiline = """This is a string
that spans multiple
lines"""
 
print(type(name))
# output: <class 'str'>
 
print(len(name))
# output: 5

Strings are immutable, which we'll talk about soon. You can't change a character in a string directly; you have to create a new string. This sounds limiting but it's actually a safety feature, strings can be passed around freely without risk of unexpected modification.

Bytes (bytes)

Raw binary data. If strings are characters, bytes are raw 0s and 1s. You create them with the b prefix. Bytes matter when you're doing things at a lower level than text, network protocols, binary file formats, encryption, and image processing all work in bytes.

data = b"hello"
more_data = bytes([72, 105])
 
print(type(data))
# output: <class 'bytes'>
 
print(data)
# output: b'hello'
 
print(more_data)
# output: b'Hi'

Most of the time you'll use strings, but bytes show up when you're reading files, working with networks, or dealing with binary formats.

None (NoneType)

The absence of a value. It's like null in other languages, but more Pythonic. None is your way of saying "there is no value here", it's not zero, it's not an empty string, it's the explicit statement that nothing exists.

result = None
 
print(type(result))
# output: <class 'NoneType'>
 
print(result)
# output: None

Functions that don't explicitly return anything return None. It's a placeholder for "nothing here." You'll also use None as a default parameter value to detect whether a caller actually passed something in.

Variable Assignment and Rebinding

Now that you know the types, let's talk about how variables actually work.

Assignment in Python is straightforward:

x = 10
name = "Bob"
price = 19.99
is_available = True

The = sign here isn't saying "x equals 10" the way a math equation would. It's saying "make the label x point to the integer object with value 10." That distinction in reading assignment is subtle but important as expressions get more complex.

But here's the thing: a variable is a name that can point to any object. You can assign an integer to x, and then reassign it to a string, and Python won't complain.

x = 10
print(x)
# output: 10
 
x = "Now I'm a string"
print(x)
# output: Now I'm a string
 
print(type(x))
# output: <class 'str'>

This flexibility is great for exploratory code, but in larger programs it can be confusing. Congratulate yourself if you avoid reassigning variables to different types, you're writing clearer code.

When you reassign a variable, the label moves to point to a new object. The old object still exists in memory, it just doesn't have a label pointing to it anymore. Eventually, Python's garbage collector will clean it up.

Assignment Variations: Augmented and Multiple

Python gives you shortcuts for common assignment patterns. These aren't just syntactic sugar, they signal intent clearly to anyone reading your code.

Augmented Assignment

If you want to add to a variable, multiply it, concatenate to it, etc., you can use augmented assignment operators. This pattern shows up constantly in loops, accumulators, and running totals:

count = 5
count += 3  # Same as: count = count + 3
print(count)
# output: 8
 
name = "hello"
name += " world"
print(name)
# output: hello world
 
price = 9.99
price *= 2
print(price)
# output: 19.98

These work with any operator: +=, -=, *=, /=, //=, %=, **=, and more. One thing to note: for immutable types like strings and numbers, augmented assignment still creates a new object and moves the label, it's just a shorthand. For mutable types like lists, += actually modifies the object in place, which is one of those subtle behavioral differences that can catch you off guard.

Multiple Assignment and Tuple Unpacking

You can assign multiple variables at once, which keeps related assignments clean and readable:

x, y, z = 1, 2, 3
print(x)
# output: 1
 
print(y)
# output: 2
 
a, b = "hello", "world"
print(a)
# output: hello

This uses something called tuple unpacking. On the right side, you're creating a tuple (a sequence of values). On the left side, you're unpacking that tuple into separate variables. We'll talk more about tuples soon, but for now just know that this is a convenient way to assign multiple values at once.

You can even swap variables without a temporary:

x = 5
y = 10
x, y = y, x
print(x)
# output: 10
 
print(y)
# output: 5

Beautiful, right? In most other languages you'd need a temporary variable to do this. Python handles it cleanly because the right side is fully evaluated before any assignment happens.

The Critical Distinction: is vs ==

Here's where Python's label model becomes essential to understand. This is one of those concepts that separates Python programmers who write reliable code from those who chase mysterious bugs.

== checks if two values are equal. It answers the question: "Do these objects have the same content?"

is checks if two variables point to the same object. It answers the question: "Are these the same object in memory?"

Most of the time you'll use ==:

x = 5
y = 5
print(x == y)
# output: True
 
print(x is y)
# output: True

Wait, x is y returned True? That's because Python caches small integers for performance reasons. Both x and y point to the same integer object in memory. But don't count on this behavior for larger numbers:

x = 256
y = 256
print(x == y)
# output: True
 
print(x is y)
# output: True
 
x = 257
y = 257
print(x == y)
# output: True
 
print(x is y)
# output: False

Different integer objects now. This is an implementation detail, not something you should rely on.

Where is becomes important is with None:

x = None
print(x == None)
# output: True
 
print(x is None)
# output: True

By convention, you should always use is None and is not None, not == None. It's clearer and faster:

result = some_function()
if result is not None:
    print("We got a result!")

And with mutable objects, is shows you the aliasing issue we talked about earlier:

list1 = [1, 2, 3]
list2 = list1
print(list1 == list2)
# output: True
 
print(list1 is list2)
# output: True

Both list1 and list2 point to the same list object. If you modify the list through one label, the other sees the change:

list1 = [1, 2, 3]
list2 = list1
list1.append(4)
print(list2)
# output: [1, 2, 3, 4]

The list was modified through list1, but list2 sees the change because it's pointing to the same object. This is the aliasing behavior that surprises everyone the first time they encounter it.

Everything Is an Object

Here's something that Python programmers in other languages often don't fully appreciate until they've been writing Python for a while: in Python, everything is an object. Not just the values you assign to variables, everything. Numbers are objects. Strings are objects. Functions are objects. Classes are objects. Even None is an object. Even True and False are objects.

What does it mean to be an object? It means that everything has a type (a class it belongs to), it has attributes and methods you can call on it, and it exists as a specific thing in memory with an identity.

You can see this in action with any value. Try calling dir() on an integer:

x = 42
print(type(x))
# output: <class 'int'>
 
print(x.bit_length())
# output: 6
 
print(x.__class__)
# output: <class 'int'>

That integer has methods. You can call .bit_length() on it. You can access its __class__ attribute. It's an object. This is true of everything in Python, numbers, strings, lists, functions, you name it.

Why does this matter practically? Because it means Python is deeply consistent. The same rules that apply to how you pass a list to a function apply to how you pass a number, a string, or even a function itself. There's no special "primitive" type that behaves differently from "real" objects. This makes Python code more uniform and predictable once you internalize the model.

It also explains why Python lets you do things that seem unusual. You can add methods to classes dynamically. You can pass functions as arguments to other functions. You can store functions in lists or dictionaries. All of this works because functions are just objects like everything else, they just happen to be objects you can call with ().

The practical takeaway: when you're not sure what you can do with a value in Python, call dir() on it to see all its methods and attributes. Everything has them, because everything is an object.

Type Conversion: When Python Does and Doesn't Help

You'll often need to convert one type to another. Python makes this explicit with conversion functions. The key word there is "explicit", Python generally won't do type conversion for you automatically, which is a feature. It means you don't get weird implicit coercions happening in the background the way you might in JavaScript.

Converting to Integer

x = int(3.14)
print(x)
# output: 3
 
y = int("42")
print(y)
# output: 42
 
z = int(True)
print(z)
# output: 1

Notice that int() truncates floats; it doesn't round them. And converting a boolean to an integer gives you 1 for True and 0 for False.

What if you try to convert something that doesn't make sense?

int("hello")
# output: ValueError: invalid literal for int() with base 10: 'hello'

Python raises a ValueError. You can't convert a string that isn't a number. This is expected and reasonable, always wrap int() and float() calls on user input or external data in a try/except block.

Converting to Float

x = float(10)
print(x)
# output: 10.0
 
y = float("3.14")
print(y)
# output: 3.14
 
z = float(True)
print(z)
# output: 1.0

Converting to String

x = str(42)
print(x)
# output: "42"
 
y = str(3.14)
print(y)
# output: "3.14"
 
z = str([1, 2, 3])
print(z)
# output: "[1, 2, 3]"

Everything can be converted to a string, so str() rarely raises an error. This is useful for logging and debugging, when in doubt about what something is, convert it to a string and print it.

Converting to Boolean

print(bool(1))
# output: True
 
print(bool(0))
# output: False
 
print(bool("hello"))
# output: True
 
print(bool(""))
# output: False
 
print(bool([1, 2, 3]))
# output: True
 
print(bool([]))
# output: False

Here's the rule: In Python, the values False, 0, 0.0, "", [], {}, None, and a few others are considered "falsy." Everything else is "truthy." This comes up constantly in conditions:

items = []
if items:
    print("We have items")
else:
    print("The list is empty")
# output: The list is empty

Because the list is empty, it's falsy, so the else block runs. This truthiness/falsiness system is one of Python's most elegant features once you're used to it, you can write if items: instead of if len(items) > 0: and the code reads more naturally.

Type Conversion Gotchas

Type conversion in Python seems straightforward until you hit the edge cases. Here are the ones that catch people most often.

The first gotcha is int() truncating toward zero, not rounding. int(2.9) gives you 2, not 3. If you want rounding, use round() first, then int(). This trips people up when they're expecting standard mathematical rounding behavior.

The second is that bool("False") returns True. This surprises almost everyone the first time. The string "False" is a non-empty string, so it's truthy. If you're reading a boolean value from a config file or environment variable and you get the string "False", you cannot simply call bool() on it. You need to explicitly compare it: value.lower() == "true" or use a proper config parsing library.

The third gotcha is integer division. In Python 3, 5 / 2 gives you 2.5, a float, not 2. If you want integer division, use //. This is actually an improvement over Python 2 and many other languages, but it surprises people coming from those environments. The related issue: if you have two integers and you want a float result, you need to ensure at least one of them is already a float or cast one explicitly.

Immutable vs Mutable: The Foundation of Python's Behavior

Here's a fundamental distinction that shapes how Python works: some types are immutable, and some are mutable.

Immutable types can't be changed after they're created. If you "modify" them, you're actually creating a new object:

• Integers
• Floats
• Strings
• Tuples
• Booleans
• None

Mutable types can be changed in place:

• Lists
• Dictionaries
• Sets

Why does this matter? Because when you pass a mutable object to a function, you're passing a label to an object. If the function modifies that object, the change persists outside the function. This is a double-edged sword: it means functions can efficiently work with large data structures without copying them, but it also means you need to be deliberate about when you want shared state versus independent copies.

def add_item(items):
    items.append("new item")
 
my_list = ["apple", "banana"]
add_item(my_list)
print(my_list)
# output: ['apple', 'banana', 'new item']

The list was modified inside the function, and the change is visible outside because both labels point to the same list object. This is intentional Python design, it lets you write functions that modify data structures efficiently without returning the whole modified structure.

With immutable objects, this can't happen:

def modify_number(num):
    num = num + 10
 
x = 5
modify_number(x)
print(x)
# output: 5

Inside the function, num = num + 10 creates a new integer object and moves the num label to point to it. The original x is unaffected because the original integer object (5) was never changed.

This is a common source of confusion. Let's make it crystal clear with a worked example:

# IMMUTABLE EXAMPLE
def try_change_string(s):
    s = s + " modified"
    print(f"Inside function: {s}")
 
original = "hello"
try_change_string(original)
print(f"Outside function: {original}")
# output:
# Inside function: hello modified
# Outside function: hello
 
# MUTABLE EXAMPLE
def modify_list(items):
    items.append("added")
    print(f"Inside function: {items}")
 
my_list = ["a", "b"]
modify_list(my_list)
print(f"Outside function: {my_list}")
# output:
# Inside function: ['a', 'b', 'added']
# Outside function: ['a', 'b', 'added']

See the difference? With strings (immutable), the change doesn't persist. With lists (mutable), it does. When you're designing functions, decide explicitly whether you want to modify the passed-in object or return a new one, and be consistent about it.

Checking Types: type() vs isinstance()

When you need to know what type something is, you have two tools. Knowing which one to reach for will make your code more robust.

type()

Returns the exact type of an object:

print(type(5))
# output: <class 'int'>
 
print(type(5.0))
# output: <class 'float'>
 
print(type("hello"))
# output: <class 'str'>
 
print(type([1, 2, 3]))
# output: <class 'list'>

isinstance()

Checks if an object is an instance of a type (or a tuple of types):

print(isinstance(5, int))
# output: True
 
print(isinstance(5, float))
# output: False
 
print(isinstance(5, (int, float)))
# output: True
 
print(isinstance("hello", str))
# output: True

Here's the key difference: isinstance() accounts for inheritance, which you'll learn about when we cover classes. For now, know that isinstance() is generally preferred because it's more flexible:

# This is more Pythonic
if isinstance(value, (int, float)):
    print("It's a number")

Than:

# This is less flexible
if type(value) == int or type(value) == float:
    print("It's a number")

In real-world code, type() is mostly useful for debugging, printing it out to see what you're dealing with. For actual conditional logic, isinstance() is the right tool because it handles subclasses correctly. When you start working with libraries like NumPy or pandas, you'll encounter types that are subclasses of Python's built-ins, and isinstance() will handle them correctly while type() == will not.

The Memory Model: Understanding the Reference Landscape

Let's solidify this with a deep dive into what's actually happening in memory.

When you write:

x = [1, 2, 3]
y = x

You're creating one list object in memory and two labels pointing to it:

┌─────────────────┐
│  [1, 2, 3]      │  <- List object in memory
└─────────────────┘
      ↑         ↑
      │         │
   (x)         (y)   <- Labels pointing to the same object

When you write:

x = [1, 2, 3]
y = [1, 2, 3]

You're creating two separate list objects, even though they have the same content:

┌──────────────┐
│  [1, 2, 3]   │  <- First list object
└──────────────┘
       ↑
      (x)

┌──────────────┐
│  [1, 2, 3]   │  <- Second list object (different object)
└──────────────┘
       ↑
      (y)

So:

x = [1, 2, 3]
y = [1, 2, 3]
print(x == y)  # Same content
# output: True
 
print(x is y)  # Different objects
# output: False

This is why careful programmers are paranoid about mutable objects:

original = [1, 2, 3]
copy = original  # WRONG: Just another label to the same object
# If you modify copy, original changes too
 
copy.append(4)
print(original)
# output: [1, 2, 3, 4]

If you actually want a copy, you need to be explicit. For lists, the simplest way is slicing:

original = [1, 2, 3]
copy = original[:]  # Creates a new list with the same elements
copy.append(4)
print(original)
# output: [1, 2, 3]

Or use the list() constructor:

original = [1, 2, 3]
copy = list(original)
copy.append(4)
print(original)
# output: [1, 2, 3]

Note that both slicing and list() create a shallow copy, a new list containing references to the same objects. For nested data structures, you may need copy.deepcopy() from the standard library to get a truly independent copy. But for flat lists of immutable values (numbers, strings), shallow copying is all you need.

Common Variable Mistakes

Even experienced developers make these mistakes when they're moving fast. Knowing them in advance will save you real debugging time.

The most common mistake is confusing assignment with equality. Writing x = 5 when you meant x == 5 inside a conditional is a logic error that Python won't warn you about, it's valid Python, it just doesn't do what you intended. Most linters will catch this, but it's worth being deliberate about the direction of your = signs.

The second common mistake is using unclear or overly short variable names. A variable named x in a 5-line script is fine. In a 200-line function, it's a maintenance hazard. Name your variables after what they represent, bill_amount, user_count, is_authenticated, not what type they are or how big they are. Good names make code self-documenting.

The third is unintentional reassignment. Because Python lets you freely reassign any variable to any type, it's easy to accidentally reuse a variable name lower in a function and overwrite a value you still needed. If you're working through a complex calculation and you assign result = some_computation() and then later assign result = some_other_computation(), you've lost your first result. Either use distinct names or store results you need to keep before overwriting.

The fourth mistake is forgetting that variable scope matters. Variables defined inside a function aren't accessible outside it. Variables defined in one branch of an if statement might not exist if the other branch runs. Python will raise a NameError if you try to use a variable that hasn't been assigned yet in that scope. Always initialize variables before any branching logic that might or might not assign them.

The Gotcha: Aliasing Bugs with Mutable Objects

This is where a lot of beginners get tripped up. Let me show you the classic mistakes and how to avoid them.

Gotcha #1: Shared Default Arguments

def append_to_list(item, items=[]):
    items.append(item)
    return items
 
result1 = append_to_list(1)
print(result1)
# output: [1]
 
result2 = append_to_list(2)
print(result2)
# output: [1, 2]  <- What?!
 
print(result1)
# output: [1, 2]  <- Oh no!

The default argument items=[] is created once, when the function is defined, not each time it's called. Both result1 and result2 point to the same list. This is almost never what you want.

The fix: use None as the default and create a new list inside the function:

def append_to_list(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items
 
result1 = append_to_list(1)
print(result1)
# output: [1]
 
result2 = append_to_list(2)
print(result2)
# output: [2]
 
print(result1)
# output: [1]

Now each call gets its own list.

Gotcha #2: Modifying While Iterating

items = [1, 2, 3, 4, 5]
for item in items:
    if item % 2 == 0:
        items.remove(item)
 
print(items)
# output: [1, 3, 5]

This might work in simple cases, but it's a recipe for bugs. When you modify a list while iterating over it, you can skip elements or get unexpected results. The safest approach: iterate over a copy, or build a new list:

items = [1, 2, 3, 4, 5]
items = [item for item in items if item % 2 != 0]
print(items)
# output: [1, 3, 5]

This creates a new list with only the odd numbers. Much safer.

Gotcha #3: Nested Mutable Objects

matrix = [[0, 0], [0, 0]]
row = matrix[0]
row[0] = 1
print(matrix)
# output: [[1, 0], [0, 0]]

row is a label pointing to the first sublist. When you modify row, you're modifying the actual sublist inside matrix. This is fine if you understand it, but it's surprising if you're not thinking carefully about references.

Recap: Bringing It All Together

Let's take our knowledge and apply it to a real-world example. Remember the tip calculator from Article 1? Let's build it again with careful attention to types and variables:

def calculate_tip(bill_amount, tip_percentage):
    """Calculate tip and total for a bill."""
    tip = bill_amount * tip_percentage / 100
    total = bill_amount + tip
    return tip, total
 
# Get input from user
bill_str = input("Enter bill amount: ")
tip_str = input("Enter tip percentage: ")
 
# Convert to numbers (handle errors)
try:
    bill = float(bill_str)
    tip_percent = float(tip_str)
except ValueError:
    print("Please enter valid numbers")
    exit()
 
# Calculate
tip_amount, total_amount = calculate_tip(bill, tip_percent)
 
# Display results
print(f"Bill: ${bill:.2f}")
print(f"Tip: ${tip_amount:.2f}")
print(f"Total: ${total_amount:.2f}")

Notice what we did:

1. We defined a function that takes two numbers and returns a tuple
2. We read input as strings
3. We explicitly converted strings to floats (and handled the case where conversion fails)
4. We unpacked the returned tuple into two variables
5. We displayed the results with formatted strings

This is professional-grade code for a simple task. You understand types, conversions, error handling, and references. Nice.

One More Thing: Reassignment in the Real World

Let's look at a common pattern where reassignment is actually useful. In the tip calculator, we reassigned bill from a string to a float:

bill_str = input("Enter bill amount: ")
bill = float(bill_str)  # Reassignment

This works, but some people prefer to keep the original string and use a different variable name:

bill_str = input("Enter bill amount: ")
bill = float(bill_str)  # Different variable

This is a stylistic choice. Both work. Some people like the reassignment because it shows that bill is "now the number we want to work with." Others prefer separate variables to keep track of what type things are. There's no right answer, just be consistent and clear.

Summary: Variables as Labels, Types as Contracts

Python's variable model is simple in concept but profound in practice. We've covered a lot of ground here, and it's worth stepping back to see how it all connects. The labels-not-boxes mental model isn't just trivia, it's the unifying explanation for why mutable objects behave the way they do, why is and == are different operators, and why copying data requires explicit intent.

Here's what to carry forward:

• Variables are labels, not boxes. They point to objects in memory.
• Types tell you what operations are available and how the object behaves.
• Everything is an object in Python, numbers, strings, functions, classes, all of it.
• Immutable types (int, float, str, tuple) can't be changed in place.
• Mutable types (list, dict, set) can be modified, and those changes are visible through all labels pointing to the same object.
• Use == to compare values, is to check object identity.
• Convert types explicitly with int(), float(), str(), bool().
• Check types with isinstance() rather than type() when possible.
• Watch out for type conversion gotchas like int() truncating, bool("False") being True, and division always returning a float.

Understanding this model, especially the distinction between mutable and immutable types, and the gotchas that come with each, will save you from debugging sessions later. Many Python bugs, including some that show up in production AI/ML systems, are rooted in misunderstanding how variables and references work. You now have the mental model to avoid them.