Variables

A fundamental tenet of programming is that programs must store information in memory to use and manipulate it. Variables are the means for doing that in almost all computer languages. They provide a way to label data with a descriptive name that helps us and other readers understand a program. Consider variables as labels that identify particular objects your program creates and uses.

Variables and Variable Names

A variable is a label attached to a specific value stored in a program's memory. Typically, variables can be changed; we can connect the variable to a different value somewhere else in memory. For brevity, we often talk of assigning or reassigning an object to a variable. We also speak of variables as containing data, though that's not entirely accurate, as we'll learn later in this book.

Consider this code:

answer = 41
print(answer)       # 41

answer = 42
print(answer)       # 42

When Python sees line 1 of this code, it sets aside a bit of memory and stores the value 41 in that area. It also creates a variable named answer that we can use to access that value.

On line 4, we reassign the value 42 to the variable named answer. That is, Python makes answer refer to a new object. In particular, you must understand that we're not changing the object that represents 41 -- we're assigning an entirely new value to the answer variable.

Variable Naming

There are two hard problems in computer science: cache invalidation, naming things, and off-by-one errors.

-- Author unknown

Properly naming variables is traditionally viewed as one of the most challenging tasks in computer programming. If you're new to programming, this might seem odd. After all, how tough can it be to choose a name? As it turns out, it is challenging. Consider how much effort many new parents require to select a name for their baby.

A variable name must accurately and concisely describe the variable's data. In large programs, it's challenging to remember what each variable contains. If you use non-descriptive names like x, i, and dct, you may forget what data that variable represents. Other readers -- programmers -- must suss out the meaning for themselves. Therefore, when naming variables, think hard about the names. Ensure they are accurate, descriptive, and understandable to other readers. That might be you when you revisit the program a few months or years later.

Variable names are often referred to by the broader term identifiers. In Python, identifiers refer to several things:

• Variable and constant names
• Function and method names
• Function and method parameter names
• Class and module names

You'll meet all these things as you move through the Launch School Core curriculum. We'll often use the term identifier when discussing names in general: variables, constants, functions, classes, etc. We'll use one of the more specific terms when we need to limit the scope of a discussion.

Naming Conventions

Closely related to the stylistic conventions discussed in the Using Python chapter are the Python naming conventions. Names that follow these conventions are idiomatic. In contrast, those that do not are non-idiomatic (valid but not idiomatic) or illegal (your code will either raise a syntax error or do something unexpected).

• Naming conventions for most identifiers (excluding constant and class names):

  • Use snake_case formatting for these names.
  • Names may contain lowercase letters (a-z), digits (0-9), and underscores (_).
  • Names should begin with a letter.
  • If the name has multiple words, separate the words with a single underscore (_).
  • Names that begin or end with one or two underscores have special meaning under the naming conventions. Don't use them until you understand how they are used.
  • Names may only use letters and digits from the standard ASCII character set.

  Idiomatic Names
  foo
  answer_to_ultimate_question
  eighty_seven
  index_2
  index2

• Constant names (unchanging named values):

  • Use SCREAMING_SNAKE_CASE formatting for these names.
  • Names may contain uppercase letters (A-Z), digits (0-9), and underscores (_).
  • Names should begin with a letter.
  • If the name has multiple words, separate the words with a single underscore (_).
  • Names that begin or end with one or two underscores have special meaning under the naming conventions. Don't use them until you understand how they are used.
  • Names may only use letters and digits from the standard ASCII character set.

  Idiomatic Names
  FOO
  ANSWER_TO_ULTIMATE_QUESTION
  EIGHTY_SEVEN
  INDEX_2
  INDEX2

  The constant naming convention is advisory only. Python has no way to ensure that constants are never changed. Whether a constant ever changes is entirely up to the programmer, not Python.

• Class names:

  • Use PascalCase formatting for these names. PascalCase is sometimes called CamelCase (with both Cs capitalized).
  • Names may contain uppercase and lowercase letters (A-Z, a-z) and digits (0-9).
  • Names should begin with an uppercase letter.
  • If the name has multiple words, capitalize each word.

  Idiomatic Names
  Foo
  UltimateQuestion
  FourLeggedPets
  PythonVersion2Rules

  We'll meet a few class names in this book but will leave a full discussion for our Object Oriented Programming in Python book.

Note that many non-idiomatic names are still legal (valid) Python identifiers. Sometimes, it makes sense to break the rules. However, not all identifiers are legal; here are some things you must do:

• You can use letters, digits, and underscores in Python identifiers. Extended ASCII and Unicode letters and digits are allowed.
• You may not use punctuation characters, most special characters, or whitespace.
• You may not start identifiers with a digit.
• You may not use Python's reserved words such as if, def, while, return, and pass as names.

Non-Idiomatic Names	Explanation
fourWayIntersection	camelCase
Schön	Extended ASCII

Illegal Names	Explanation
pass	Reserved word
3xy	Starts with digit
ultimate-question	Hyphen
one two three	Whitespace
is_lowercase?	Punctuation
is+lowercase	Special character

Most illegal names will raise an error. However, if the illegal name looks like valid Python, you won't get an error:

first,last = ['Mary', 'Wonder']

That example creates two variables, first and last, and assigns them to Mary and Wonder, respectively.

Creating and Reassigning Variables

We create (initialize) most variables by simply giving them a value. That happens as part of an assignment statement:

forename = 'Clare'       # initialization (also called assignment)

Initializations are also said to provide a definition for the variable.

No special keywords are required to define variables. We can also give new values to variables by simply reassigning them:

forename = 'Clare'       # initialization (also called assignment)
# omitted code
forename = 'Victor'      # reassignment

How Initialization and Reassignment Work

When you initialize a variable, Python gives it an initial value and sticks that value somewhere in the computer's memory. It also allocates a small amount of memory for the variable itself, then places the value's memory address into the variable's spot in memory.

For instance, consider this code:

foo = 'abcdefghi'

When Python encounters this code, it will create the string 'abcdefghi' somewhere in memory. Let's assume Python stores the string at memory address 73420. Next, it creates a variable somewhere else in memory. Let's suppose the variable is at address 10230. It then associates address 10230 with the name foo. Python stores the address of the string (73420) at address 10230. Thus, we get a situation that looks like this:

Consider what happens when we later run this reassignment:

foo = 'Hello'

Python creates the new string 'Hello' somewhere in memory. We can assume that 'Hello' is stored at memory address 87160. Since we already have a foo variable, Python simply replaces the value at address 10230 with 87160. This breaks the connection with the original string and establishes a new one with the new string. Things now look like this:

Creating Constants

Constants are created (initialized) in the same way as variables: by giving them a value. That happens as part of an assignment statement:

PINING_FOR = 'fjords'         # initialization

As with variable creation, no keywords are required to create constants. However, you should use SCREAMING_SNAKE_CASE in observation of the constant naming convention.

Since constants should be unchanging, you should never reassign a constant.

Constants are usually defined in the global scope. The definitions are usually written at the top of the program file, just below any imports. You can use constants anywhere, but they should be defined globally. Thus, you can use constants in functions, but you shouldn't create a constant inside a function.

Expressions and Assignment

Assignment and reassignment are often more complex than simply assigning a literal value to a variable. Assignment and reassignment often use expressions on the right side of the = to determine the desired value. For instance:

left_side = 5
right_side = 32
total = left_side + right_side  # total = 37
print(total)                    # prints 37

This code starts with two simple assignments that initialize the left_side and right_side variables to 5 and 32, respectively. Next, we add the values of left_side and right_side together and assign the result to total, which we then print.

Here's an example that uses a function call to compute the resulting value for the assignment:

def square(number):
    return number * number

forty_two_squared = square(42)
print(forty_two_squared)                # 1764

The expression on the right side of the = operator can be any valid expression. It can be as simple or complex as needed, though you should strive to keep them readable and easy to understand.

The variable to the left of the = operator is always the target variable for the resulting value. That is, the expression's value will be assigned to the variable.

It's worth noting that the right side of an assignment is always completely evaluated before assigning the result to the variable. That means you can write code like this:

foo = 42            # foo is 42
foo = foo - 2       # foo is now 40
foo = foo * 3       # foo is now 120
foo = foo + 5       # foo is now 125
foo = foo // 25     # foo is now 5
foo = foo / 2       # foo is now 2.5
foo = foo**3        # foo is now 15.625
print(foo)          # prints 15.625

In lines 2-7, the right side of each assignment is computed first using whatever value foo had most recently. Thus, foo was 42 on line 2, 40 on line 3, and so on. On each line, a computation is performed using the current value of foo. Python then reassigns the newly computed value to foo.

You can also use expressions to initialize constants. However, this is less common than evaluating expressions for a variable.

Augmented Assignment

The assignments at the end of the previous section all follow a similar pattern: they take the current value of a variable, perform an arithmetic operation on the variable's value, and then reassign the variable to the newly computed value. This sort of operation is so common that most languages have a shorthand notation called augmented assignment or assignment operators:

foo = 42            # foo is 42
foo -= 2            # foo is now 40
foo *= 3            # foo is now 120
foo += 5            # foo is now 125
foo //= 25          # foo is now 5
foo /= 2            # foo is now 2.5
foo **= 3           # foo is now 15.625
print(foo)          # prints 15.625

Each statement is noticeably shorter than the original, but the results are identical. While there's little or no performance benefit to augmented assignment, most developers find the syntax more readable, and you're less likely to misspell one of the variable names.

Augmented assignment also works with string concatenation and repetition. In fact, it works with any type that supports the various operators.

bar = 'xyz'          # bar is 'xyz'
bar += 'abc'         # bar is now 'xyzabc'
bar *= 2             # bar is now 'xyzabcxyzabc'
print(bar)           # prints xyzabcxyzabc

bar = [1, 2, 3]     # bar is [1, 2, 3]
bar += [4, 5]       # + with lists appends
                    # bar is now [1, 2, 3, 4, 5]
print(bar)          # prints [1, 2, 3, 4, 5]

bar = {1, 2, 3}     # bar is {1, 2, 3}
bar |= {2, 3, 4, 5} # | performs set union
                    # bar is now {1, 2, 3, 4, 5}
bar -= {2, 4}       # - performs set difference
                    # bar is now {1, 3, 5}
print(bar)          # prints {1, 3, 5}

Augmented assignment also works with constants. However, as with constant reassignment, it is poor practice.

Note that augmented assignment is a statement, not an expression. Thus, you can't use augmented assignment as a function argument or return value:

def foo(bar):
    print(bar)

a = 3
foo(a *= 2)
#     ^^
# SyntaxError: invalid syntax

def foo():
    a = 3
    return a *= 2
#            ^^
# SyntaxError: invalid syntax

Reassignment vs. Mutation

There are two ways to change things in Python and most other programming languages. You can change the binding of the variable by making it reference a new object, or you can change the value of the object assigned (bound) to the variable. The former is known as reassignment while the latter is known as mutation.

A variable is a name that refers to an object at a specific place in memory. Reassignment makes that name refer to a different object somewhere else in memory. Mutation, on the other hand, does not change which object the variable refers to. Instead, it changes the object itself. After mutating an object assigned to a specific variable, the variable continues to refer to the same object (albeit altered) at the same memory location.

This distinction is crucial in any language that permits reassignment and mutation, as it significantly impacts how those languages work. One subtle but important distinction is the difference between reassigning a variable and reassigning an element in a list, dict, or other mutable collection. Reassigning an element of a mutable collection doesn't reassign the variable; it mutates the collection.

Here are some examples illustrating the differences between reassignment and mutation. Pay close attention, as this is a crucial concept.

num = 3               # assignment (initialization)
my_list = [1, 2, 3]   # assignment (initialization)
my_dict = {           # assignment (initialization)
    'a': 1,
    'b': 2,
}

num = 42              # Reassignment
my_list[1] = 42       # Reassignment of element,
                      # my_list is mutated!
my_dict['b'] = 3      # Reassignment of dict pair
                      # my_dict is mutated!

# You can still reassign the variables
my_list = [2, 3, 4]   # Reassignment
my_dict = { 'x': 0 }  # Reassignment

As much as possible, we use the terms mutation or mutate to describe any mutating operation. We'll talk more about these concepts throughout this book and in almost every course at Launch School. For now, keep the distinction between reassignment and mutation in mind.

Summary

In this chapter, we've learned how to use variables and constants to store information for later use. In particular, we've learned what variables and constants are and how we use and manipulate them. We've also learned how to assign and reassign variables and how to use augmented assignment.

Mutation and reassignment are two more fundamental concepts. Understanding mutation will help you catch, fix, and avoid an entire class of bugs.

Let's apply that knowledge in some exercises.